> For the complete documentation index, see [llms.txt](https://ayakaleaf-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://ayakaleaf-pro.ayaka.space/latex/nl/class-bestanden/04-writing-your-own-class.md).

# Je eigen class schrijven

Soms is de beste optie om een document aan te passen, een nieuwe klasse vanaf nul te schrijven. Dit artikel legt de belangrijkste structuur en de benodigde commando's in een nieuwe klasse uit.

## Inleiding

Het eerste wat je moet doen voordat je een nieuwe klasse codeert, is bepalen of je echt een nieuwe klasse nodig hebt of niet. Het wordt aanbevolen om [te zoeken op CTAN (Comprehensive TeX Archive Network)](http://www.ctan.org/ctan-portal/search/) en te kijken of iemand al iets soortgelijks heeft gemaakt als de documentklasse die je nodig hebt.

Een ander belangrijk punt om in gedachten te houden is [het verschil tussen pakketten en klassen](/latex/nl/class-bestanden/01-understanding-packages-and-class-files.md). De verkeerde keuze kan de flexibiliteit van het eindproduct beïnvloeden.

## Algemene structuur

De structuur van alle klassebestanden kan grofweg worden beschreven in de volgende vier delen:

* ***Identificatie***. Het bestand declareert zichzelf als een klasse geschreven met de LaTeX2ε-syntaxis.
* ***Voorlopige declaraties***. Hier worden de externe pakketten en klassen die nodig zijn geïmporteerd. Ook worden in dit deel van het bestand de commando's en definities geïmplementeerd die nodig zijn voor de gedeclareerde opties.
* ***Opties***. De klasse declareert en verwerkt de opties.
* ***Meer declaraties***. Het hoofdgedeelte van de klasse. Bijna alles wat een klasse doet, wordt hier gedefinieerd.

In de volgende subsecties worden een gedetailleerdere beschrijving van de structuur en een werkend voorbeeld, *exampleclass.cls*, gepresenteerd.

### Identificatie

Er zijn twee eenvoudige commando's die alle klassen moeten hebben:

```latex
\NeedsTeXFormat{LaTeX2e}
\ProvidesClass{exampleclass}[2014/08/16 Example LaTeX class]
```

Het commando `\NeedsTeXFormat{LaTeX2e}` stelt de LaTeX-versie in waarmee de klasse moet werken. Bovendien kan tussen vierkante haken een datum worden toegevoegd om de minimaal vereiste releasedatum aan te geven.

Het commando `ProvidesClass{exampleclass}[...]` identificeert deze klasse als *exampleclass* en binnen de haken zijn de releasedatum en enkele aanvullende gegevens opgenomen. De datum moet de vorm YYYY/MM/DD hebben

[Open een voorbeeld van hoe je een klasse schrijft in Overleaf](https://www.overleaf.com/project/new/template/19419?id=65524436\&templateName=An+example+of+writing+a+LaTeX+class\&latexEngine=\&texImage=texlive-full%3A2020.1\&mainFile=)

### Voorlopige declaraties

De meeste klassen breiden bestaande uit en passen die aan, en hebben ook enkele externe pakketten nodig om te werken. Hieronder wordt wat meer code toegevoegd aan de voorbeeldklasse `exampleclass.cls`.

```latex
\NeedsTeXFormat{LaTeX2e}
\ProvidesClass{exampleclass}[2014/08/16 Example LaTeX class]

\newcommand{\headlinecolor}{\normalcolor}
\LoadClass[twocolumn]{article}
\RequirePackage{xcolor}
\definecolor{slcolor}{HTML}{882B21}
```

De commando's in dit deel initialiseren ofwel enkele parameters die later zullen worden gebruikt om de opties te beheren, ofwel importeren externe bestanden.

Het commando `\LoadClass[twocolumn]{article}` laadt de klasse `article` met de extra parameter `twocolumn`. Daarom zullen alle commando's in de standaard `article` klasse automatisch beschikbaar zijn in de **example** klasse, behalve dat het document in een tweekolomsopmaak wordt afgedrukt.

`\RequirePackage` lijkt sterk op de bekende `\usepackage`, het toevoegen van optionele parameters tussen vierkante haken werkt ook. Het enige verschil is dat de `\usepackage` kan niet worden gebruikt vóór `\documentclass` commando. Het wordt sterk aanbevolen om `\RequirePackage` wanneer je nieuwe klassen of pakketten schrijft.

[Open een voorbeeld van hoe je een klasse schrijft in Overleaf](https://www.overleaf.com/project/new/template/19419?id=65524436\&templateName=An+example+of+writing+a+LaTeX+class\&latexEngine=\&texImage=texlive-full%3A2020.1\&mainFile=)

### Opties

Om enige flexibiliteit in de klassen toe te staan, zijn een paar extra opties erg nuttig. Het volgende deel in het bestand `exampleclass.cls` verwerkt de parameters die aan het documentklasse-commando zijn doorgegeven. We hebben ook `\LoadClass` om *na* de opties worden verwerkt, zodat opties die in het .tex-bestand zijn ingesteld, aan de basisklasse kunnen worden doorgegeven.

```latex
\NeedsTeXFormat{LaTeX2e}
\ProvidesClass{exampleclass}[2014/08/16 Example LaTeX class]

\newcommand{\headlinecolor}{\normalcolor}
\RequirePackage{xcolor}
\definecolor{slcolor}{HTML}{882B21}

\DeclareOption{onecolumn}{\OptionNotUsed}
\DeclareOption{green}{\renewcommand{\headlinecolor}{\color{green}}}
\DeclareOption{red}{\renewcommand{\headlinecolor}{\color{slcolor}}}
\DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}
\ProcessOptions\relax
\LoadClass[twocolumn]{article}
```

Er zijn hier vier hoofdcommando's die de aan de klasse doorgegeven opties verwerken.

Het commando `\DeclareOption{}{}` verwerkt een gegeven optie. Het neemt twee parameters: de eerste is de naam van de optie en de tweede is de code die moet worden uitgevoerd als de optie wordt doorgegeven.

Het commando `\OptionNotUsed` zal een bericht afdrukken in de compiler en de logs, de optie wordt niet gebruikt. In dit geval staat het document op twee kolommen en als de gebruiker probeert dit naar één kolom te wijzigen, zal dat niet werken; de optie wordt genegeerd.

Het commando `\Declareoption*{}` verwerkt elke optie die niet expliciet is gedefinieerd. Het neemt slechts één parameter, de code die moet worden uitgevoerd wanneer een onbekende optie wordt doorgegeven. In dit geval zal het het volgende commando uitvoeren:

`\PassOptionsToClass{}{}`. Geeft de optie binnen de eerste paar accolades door aan de documentklasse die is ingesteld binnen de tweede paar accolades. In het voorbeeld worden alle onbekende opties doorgegeven aan de **article** documentklasse.

`\CurrentOption` slaat de naam op van de klasse-optie die op een bepaald moment wordt verwerkt.

Het commando `\ProcessOptions\relax` voert de code voor elke optie uit en moet worden ingevoegd nadat alle commando's voor het verwerken van opties zijn getypt. Er bestaat een stervormige versie van dit commando die de opties uitvoert in exact de volgorde die is opgegeven door de aanroepende commando's.

In het voorbeeld, als de opties `red` of `green` worden doorgegeven aan het document wordt het lettertype dat gebruikt wordt voor de kop en de secties ingesteld op de overeenkomstige kleur. De kleur genaamd `slcolor` werd gedefinieerd in de [voorlopige declaraties](#preliminary-declaration) na het importeren van de `xcolor` pakket niet te gebruiken.

[Open een voorbeeld van hoe je een klasse schrijft in Overleaf](https://www.overleaf.com/project/new/template/19419?id=65524436\&templateName=An+example+of+writing+a+LaTeX+class\&latexEngine=\&texImage=texlive-full%3A2020.1\&mainFile=)

### Meer declaraties

In dit deel zullen de meeste commando's verschijnen. In "exampleclass.cls" worden de afmetingen van de pagina, de lettergrootte voor de titel, de hoofdtekst en de secties ingesteld. Hieronder zie je het volledige klassebestand.

```latex
\NeedsTeXFormat{LaTeX2e}
\ProvidesClass{exampleclass}[2014/08/16 Example LaTeX class]

\newcommand{\headlinecolor}{\normalcolor}
\RequirePackage{xcolor}
\definecolor{slcolor}{HTML}{882B21}

\DeclareOption{onecolumn}{\OptionNotUsed}
\DeclareOption{green}{\renewcommand{\headlinecolor}{\color{green}}}
\DeclareOption{red}{\renewcommand{\headlinecolor}{\color{slcolor}}}
\DeclareOption*{\PassOptionsToClass{\CurrentOption}{article}}
\ProcessOptions\relax
\LoadClass[twocolumn]{article}

\renewcommand{\maketitle}{%
    \twocolumn[%
        \fontsize{50}{60}\fontfamily{phv}\fontseries{b}%
        \fontshape{sl}\selectfont\headlinecolor
        \@title
        \medskip
        ]%
}

\renewcommand{\section}{%
    \@startsection
    {section}{1}{0pt}{-1.5ex plus -1ex minus -.2ex}%
    {1ex plus .2ex}{\large\sffamily\slshape\headlinecolor}%
}

\renewcommand{\normalsize}{\fontsize{9}{10}\selectfont}
\setlength{\textwidth}{17.5cm}
\setlength{\textheight}{22cm}
\setcounter{secnumdepth}{0}
```

Om de rest van de commando's te begrijpen, zie de [naslaggids](#reference-guide) en de links in de [sectie verder lezen](#further-reading).

De laatste vier commando's in het voorbeeld laten de vier dingen zien die alle klassen moeten bevatten:

* De definitie van `normalsize`. Stelt de standaard [lettergrootte](/latex/nl/lettertypen/01-font-sizes-families-and-styles.md).
* Een standaardwaarde voor [`textwidth`](/latex/nl/opmaak/07-page-size-and-margins.md)
* Een standaardwaarde voor [`teksthoogte`](/latex/nl/opmaak/07-page-size-and-margins.md)
* De specificaties voor de [paginanummering](/latex/nl/opmaak/03-page-numbering.md).

Hieronder een document dat de klasse *exampleclass.cls*.

```latex
\documentclass[red]{exampleclass}
\usepackage[utf8]{inputenc}
\usepackage[english]{babel}

\usepackage{blindtext}

\title{Example to show how classes work}
\author{Team Learn ShareLaTeX}
\date{August 2014}

\begin{document}

\maketitle

\noindent
Laten we hier beginnen met een eenvoudig werkend voorbeeld.

\blindtext

\section{Introduction}

Het Monty Hall-probleem...

\section{The same thing}

De Monty...
```

![WrittingClassesEx1.png](/files/c9428edd2d1c20e0336f914e81404a183f452fe3)

Merk op dat het eerste commando hier

```latex
\documentclass[red]{exampleclass}
```

[Open een voorbeeld van hoe je een klasse schrijft in Overleaf](https://www.overleaf.com/project/new/template/19419?id=65524436\&templateName=An+example+of+writing+a+LaTeX+class\&latexEngine=\&texImage=texlive-full%3A2020.1\&mainFile=)

## Fouten afhandelen

Als het gaat om het ontwikkelen van nieuwe klassen, is het belangrijk om mogelijke fouten af te handelen om de gebruiker te laten weten dat er iets mis is gegaan. Er zijn vier hoofdcommando's om fouten in de compiler te rapporteren.

* `\ClassError{*class-name*}{*error-text*}{*help-text*}`. Neemt drie parameters, elk tussen accolades: de klassenaam, de fouttekst die wordt weergegeven (het compilatieproces wordt gepauzeerd) en de helptekst die wordt afgedrukt als de gebruiker op "h" drukt wanneer de compilatie pauzeert vanwege de fout.
* `\ClassWarning{*class-name*}{*warning-text*}`. In dit geval wordt de tekst weergegeven, maar het compilatieproces stopt niet. Het toont het regelnummer waar de waarschuwing optrad.
* `\ClassWarningNoLine{*class-name*}{*warning-text*}`. Werkt net als het vorige commando, maar toont niet de regel waar de waarschuwing optrad.
* `\ClassInfo{*class name*}{*info-text*}`. In dit geval wordt de informatie in de tweede parameter alleen afgedrukt in het transcriptbestand, inclusief het regelnummer.

[Open een voorbeeld van hoe je een klasse schrijft in Overleaf](https://www.overleaf.com/project/new/template/19419?id=65524436\&templateName=An+example+of+writing+a+LaTeX+class\&latexEngine=\&texImage=texlive-full%3A2020.1\&mainFile=)

## Naslaggids

**Lijst van commando's die vaak worden gebruikt in klassen en pakketten**

* `\newcommand{*name*}{*definition*}`. Definieert een [nieuw commando](/latex/nl/opdrachten/01-commands.md#defining-a-new-command), de eerste parameter is de naam van het nieuwe commando, de tweede parameter is wat het commando zal doen.
* `\renewcommand{}{}`. Hetzelfde als `\newcommand` maar zal een bestaand commando overschrijven.
* `\providecommand{}{}`. Werkt precies als `\newcommand` maar als het commando al is gedefinieerd, wordt dit commando stilzwijgend genegeerd.
* `\CheckCommand{}{}`. De syntaxis is hetzelfde als `\newcommand`, maar in plaats daarvan zal het controleren of het commando bestaat en de verwachte definitie heeft; LaTeX zal een waarschuwing tonen als het commando niet is wat `\CheckCommand` verwacht werd.
* `\setlength{}{}`. Stelt de lengte van het element dat als eerste parameter wordt doorgegeven in op de waarde die als tweede parameter is geschreven.
* `\mbox{}`. Maakt een vak dat de elementen bevat die tussen de accolades staan.
* `\fbox{}`. Hetzelfde als `\mbox`, maar er wordt daadwerkelijk een vak om de inhoud heen afgedrukt.

## Verder lezen

Zie voor meer informatie

* [Begrijpen van pakketten en klassebestanden](/latex/nl/class-bestanden/01-understanding-packages-and-class-files.md)
* [Je eigen pakket schrijven](/latex/nl/class-bestanden/03-writing-your-own-package.md)
* [Opdrachten](/latex/nl/opdrachten/01-commands.md) en [Omgevingen](/latex/nl/opdrachten/02-environments.md)
* [Lengtes in LaTeX](/latex/nl/opmaak/01-lengths-in-latex.md)
* [Kleuren gebruiken in LaTeX](/latex/nl/opmaak/13-using-colors-in-latex.md)
* [Beheer in een groot project](/latex/nl/documentstructuur/07-management-in-a-large-project.md)
* [LaTeX2ε voor auteurs van klassen en pakketten](http://www.latex-project.org/guides/clsguide.pdf)
* [Opmerkingen over programmeren in TeX](http://pgfplots.sourceforge.net/TeX-programming-notes.pdf)
* [Minuten in minder dan uren: LaTeX-bronnen gebruiken](https://tug.org/pracjourn/2005-4/hefferon/hefferon.pdf)
* [The LaTeX Companion. Tweede editie](http://ptgmedia.pearsoncmg.com/images/9780201362992/samplepages/0201362996.pdf)


---

# 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://ayakaleaf-pro.ayaka.space/latex/nl/class-bestanden/04-writing-your-own-class.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.
