calibre - en to nl translation catalogue (121 entries)

en: The calibre template language
nl: De calibre sjabloontaal

en: The calibre template language is a calibre-specific language used throughout calibre for tasks such as specifying file paths, formatting values, and computing the value for user-specified columns. Examples:
nl: De calibre sjabloontaal is een calibre-eigen taal gebruikt doorheen calibre voor taken zoals specificeren van bestandspaden, opmaken van waarden en berekenen van de waarde voor gebruiker-gespecificeerde kolommen. Voorbeelden:

en: Specify the folder structure and file names when saving files from the calibre library to the disk or e-book reader.
nl: Specificeer de mappenstructuur en bestandsnamen bij opslaan van bestanden van de calibre bibliotheek naar de schijf of e-boekreader.

en: Define rules for adding icons and colors to the calibre book list.
nl: Definieer regels voor toevoegen van iconen en kleuren aan calibre's boekenlijst.

en: Define `virtual columns` that contain data from other columns.
nl: Definieer `virtuele kolommen` die data bevatten van andere kolommen.

en: Advanced library searching.
nl: Geavanceerd bibliotheek zoeken.

en: Advanced metadata search and replace.
nl: Geavanceerd metadata zoeken en vervangen.

en: The language is built around the notion of a `template`, which specifies which book metadata to use, computations on that metadata, and how it is to be formatted.
nl: De taal is gebouwd rond het concept van een `sjabloon` die specificeert welke metadata te gebruiken, berekeningen op die metadata en hoe het opgemaakt moet worden.

en: Basic templates
nl: Basis sjablonen

en: A basic template consists one or more ``template expressions``. A ``template expression`` consists of text and names in curly brackets (``{}``) that is replaced by the corresponding metadata from the book being processed. For example, the default template in calibre used for saving books to device has 4 ``template expressions``::
nl: Een basissjabloon bestaat uit één of meer ``template expressions``. Een ``template expression`` bestaat uit tekst en namen tussen accolades (``{}``) die wordt vervangen door de overeenkomende metadata van het boek in verwerking. Bv. de standaard sjabloon in calibre gebruikt voor boeken naar toestel opslaan heeft vier ``template expressions``::

en: For the book "The Foundation" by "Isaac Asimov" the  will become::
nl: Voor het boek "The Foundation" door "Isaac Asimov" wordt dit::

en: The slashes are not ``template expressions`` because they are in between in ``{}``. Such text is left where it appears. For example, if the template is::
nl: De schuine strepen zijn geen ``template expressions`` omdat ze tussen ``{}`` staan. Zulke tekst blijft waar ie is. Bv., als de sjabloon is::

en: then for "The Foundation" the template produces::
nl: dan voor "The Foundation" produceert de sjabloon::

en: A ``template expression`` can access all the metadata available in calibre, including custom columns (columns you create yourself), by using a column's ``lookup name``. To find the lookup name for a `column` (sometimes called `fields`), hover your mouse over the column header in calibre's book list. Lookup names for custom columns always begin with ``#``. For series type columns there is an additional field named ``#lookup name_index`` that is the series index for that book in the series. For example, if you have a custom series column named ``#myseries``, there will also be a column named ``#myseries_index``. The standard series column's index is named ``series_index``.
nl: Een ``template expression`` heeft toegang tot alle metadata in calibre, inbegrepen aangepaste kolommen (kolommen die u zelf creëerde), door de kolom z'n ``lookup name`` te gebruiken. Om een `kolom` z'n lookup name te vinden (soms `velden` genaamd), zweef met uw muis over de kolom header in calibre's boekenlijst. Lookup names voor aangepaste kolommen beginnen altijd met ``#``. Voor reeks type kolommen is er een bijkomend veld genaamd ``#lookup name_index`` wat de serie index is voor dat boek in de serie. Bv., als u een aangepaste serie hebt genaamd ``#myseries`` dan zal er ook een kolom zijn genaamd ``#myseries_index``. De standaard serie kolom index heet ``series_index``.

en: In addition to the standard column based fields, you also can use:
nl: Naast de kolom gebaseerde velden, kunt u gebruik maken van:

en: ``{formats}`` - A list of formats available in the calibre library for a book
nl: ``{formats}`` - Een lijst van formaten beschikbaar in de calibre bibliotheek voor een boek

en: ``{identifiers:select(isbn)}`` - The ISBN of the book
nl: ``{identifiers:select(isbn)}`` - De ISBN van het boek

en: If the metadata for the field for a given book is not defined then the field in the template is replaced by the empty string (``''``). For example, consider the following template::
nl: Als de metadata voor het veld voor een bepaald boek niet gedefinieerd is wordt het veld in de sjabloon vervangen door de lege string (``''``). Bv. overweeg volgende sjabloon::

en: If Asimov's book "Second Foundation" is in the series "Foundation" then the template produces::
nl: Als Asimov's boek "Second Foundation" in de serie "Foundation" is dan geeft de sjabloon::

en: If a series has not been entered for the book then the template produces::
nl: Als er voor een boek geen serie is ingevoerd geeft de sjabloon::

en: The template processor automatically removes multiple slashes and leading or trailing spaces.
nl: De sjabloonverwerker verwijdert automatisch meerdere schuine strepen en voorloop en volg spaties.

en: Advanced formatting
nl: Geavanceerde opmaak

en: In addition to metadata substitution, templates can conditionally include additional text and control how substituted data is formatted.
nl: Bovenop metadatasubstitutie kunnen sjablonen voorwaardelijk extra tekst opnemen en de opmaak van gesubstitueerde gegevens controleren.

en: **Conditionally including text**
nl: **Voorwaardelijk tekst opnemen**

en: Sometimes you want text to appear in the output only if a field is not empty. A common case is ``series`` and ``series_index`` where you want either nothing or the two values separated by a hyphen. calibre handles this case using a special ``template expression`` syntax.
nl: Soms wilt u dat tekst enkel in de uitvoer verschijnt als een veld niet leeg is. Een veel voorkomend geval is ``series`` en ``series_index`` waar u ofwel niets wil of de twee waarden gescheiden door een streepje. calibre doet dit via een speciale ``template expression`` syntaxis.

en: For example and using the above Foundation example, assume you want the template to produce `Foundation - 3 - Second Foundation`. This template produces that output:
nl: Bv. met het Foundation voorbeeld van boven, veronderstel dat u wilt dat de sjabloon `Foundation - 3 - Second Foundation` geeft. Deze sjabloon geeft die uitvoer:

en: However, if a book has no series the template will produce `- - the title`, which is probably not what you want. Generally, people want the result be the title without the extraneous hyphens. You can accomplish this using the following template syntax:
nl: Alhoewel, als een boek geen deel van een serie is, geeft de sjabloon  `- - de titel`, wat waarschijnlijk niet is wat u wilt. Gewoonlijk willen de mensen als resultaat de titel zonder extra streepjes. Dit kan met de volgende sjabloon syntaxis:

en: This ``template expression`` says that if ``field`` has the value `XXXX` then the result will be `prefix_textXXXXXsuffix_text`. If ``field`` is empty (has no value) then the result will be the empty string (nothing) because the prefix and suffix are ignored. The prefix and suffix can contain blanks.
nl: Deze ``template expression`` zegt dat als ``field`` de waarde `XXXX` heeft, het resultaat `prefix_textXXXXXsuffix_text` zal zijn. Als ``field`` leeg is (heeft geen waarde) dan zal het resultaat de lege string zijn (niets) omdat voor- en achtervoegsel genegeerd worden. Het voor- en achtervoegsel kunnen lege plekken hebben.

en: **Do not use subtemplates (`{ ... }`) or functions (see below) in the prefix or the suffix.**
nl: **Gebruik geen subsjablonen (`{ ... }`) of functies (zie onder) in het voor- of achtervoegsel.**

en: Using this syntax, we can solve the above no-series problem with the template::
nl: Met deze syntaxis kunnen we het geen-serie probleem boven oplossen met de sjabloon::

en: The hyphens will be included only if the book has a series index, which it has only if it has a series. Continuing the Foundation example again, the template will produce `Foundation - 1 - Second Foundation`.
nl: De streepjes komen er enkel bij als het boek een serie index heeft, die het enkel heeft als het deel van een serie is. Verder weer met het Foundation voorbeeld, de sjabloon geeft `Foundation - 1 - Second Foundation`.

en: Notes:
nl: Aantekeningen:

en: You must include the colon after the ``lookup name`` if you are using a prefix or a suffix.
nl: U moet een dubbel punt zetten na de ``lookup name`` als u een voor- of achtervoegsel gebruikt.

en: You must either use either no or both ``|`` characters. Using one, as in ``{field:| - }``, is not allowed.
nl: U moet ofwel beide ofwel geen ``|`` karakters gebruiken. Eén gebruiken, zoals in ``{field:| - }``, is niet toegelaten.

en: It is OK to provide no text for either the prefix or the suffix, such as in ``{series:|| - }``. The template ``{title:||}`` is the same as ``{title}``.
nl: Het is oké om geen tekst te voorzien voor voor- of achtervoegsel, zoals in ``{series:|| - }``. De sjabloon ``{title:||}`` is hetzelfde als ``{title}``.

en: **Formatting**
nl: **Opmaak**

en: Suppose you want the ``series_index`` to be formatted as three digits with leading zeros. This does the trick:
nl: Veronderstel dat u ``series_index`` opgemaakt wilt als drie cijfers met voorloopnullen. Dit doet de truc:

en: ``{series_index:0>3s}`` - Three digits with leading zeros
nl: ``{series_index:0>3s}`` - Drie cijfers met voorloopnullen

en: For trailing zeros, use:
nl: Voor volgnullen, gebruik:

en: ``{series_index:0<3s}`` - Three digits with trailing zeros
nl: ``{series_index:0<3s}`` - Drie cijfers met volgnullen

en: If you use series indices with fractional values, e.g., 1.1, you might want the decimal points to line up. For example, you might want the indices 1 and 2.5 to appear as 01.00 and 02.50 so that they will sort correctly on a device that does lexical sorting. To do this, use:
nl: Als u reeksindexen gebruikt met fractionele waarden, bv. 1,1, hebt u de komma's misschien graag uitgelijnd. Bv. u hebt misschien graag dat indexen 1 en 2,5 eruit zien als 01,00 en 02,50 zodat ze correct sorteren op een toestel dat lexicaal sorteert. Om dit te doen, gebruik:

en: ``{series_index:0>5.2f}`` - Five characters consisting of two digits with leading zeros, a decimal point, then 2 digits after the decimal point.
nl: ``{series_index:0>5.2f}`` - Vijf karakters bestaande uit twee cijfers met voorloopnullen, een komma en twee cijfers na de komma.

en: If you want only the first two letters of the data, use:
nl: Als u enkel de twee eerste letters van de data wil, gebruik:

en: ``{author_sort:.2}`` - Only the first two letters of the author sort name
nl: ``{author_sort:.2}`` - Enkel de eerste twee letters van de auteursorteernaam

en: Much of the calibre template language formatting comes from Python. For more details on the syntax of these advanced formatting operations see the `Python documentation <https://docs.python.org/3/library/string.html#formatstrings>`_.
nl: Veel van de calibre sjabloontaalvormgeving komt van Python. Voor meer details over de syntaxis van deze geavanceerde vormgevingsoperaties zie de `Python documentatie <https://docs.python.org/3/library/string.html#formatstrings>`_.

en: Using templates to define custom columns
nl: Sjablonen gebruiken om aangepaste kolommen te definiëren

en: Templates can be used to display information that isn't in calibre metadata, or to display metadata differently from calibre's normal format. For example, you might want to show the ``ISBN``, a field that calibre does not display. You can accomplish this creating a custom column with the type `Column built from other columns` (hereafter called `composite columns`) and providing a template to generate the displayed text. The column will display the result of evaluating the template. For example, to display the ISBN, create the column and enter ``{identifiers:select(isbn)}`` in the template box. To display a column containing the values of two series custom columns, separated by a comma, use ``{#series1:||,}{#series2}``.
nl: Sjablonen kunnen gebruikt worden om informatie weer te geven niet in calibre's metadata of metadata afwijkend van calibre's gewone formaat. Bv. u wilt misschien het ``ISBN`` tonen, een veld dat calibre niet weergeeft. Dit kan door een aangepaste kolom te creëren van het type `Kolom gemaakt van andere kolommen` (hierna `samengestelde kolommen`) en een sjabloon te voorzien om de weer te geven tekst te genereren. De kolom geeft het resultaat weer van het evalueren van de sjabloon. Bv. om het ISBN weer te geven, creëer de kolom en voer ``{identifiers:select(isbn)}`` in in het sjabloon vak. Om een kolom weer te geven met de waardes van twee series aangepaste kolommen, gescheiden door een komma, gebruik ``{#series1:||,}{#series2}``.

en: Composite columns can use any template option, including formatting.
nl: Samengestelde kolommen kunnen elke sjabloonoptie gebruiken, inclusief opmaak.

en: Note: You cannot edit the data displayed in a composite column. Instead you edit the source columns. If you edit a composite column, for example by double-clicking it, calibre will open the template for editing, not the underlying data.
nl: Nota: U kan data getoond in een samengestelde kolom niet bewerken. U moet de bronkolommen bewerken. Als u een samengestelde kolom bewerkt, bv. door erop dubbel te klikken, zal calibre de bewerksjabloon openen, niet de onderliggende data.

en: a plugboard with an exact match on format and device, e.g., ``EPUB`` and ``ANDROID``
nl: een adapter met een exacte overeenkomst op formaat en toestel, bv. ``EPUB`` en ``ANDROID``

en: a plugboard with the special ``any format`` choice and an exact match on device, e.g., ``any format`` and ``ANDROID``
nl: een adapter met de speciale ``any format`` keuze en een exacte overeenkomst op toestel, bv. ``any format`` en ``ANDROID``

en: The tags and authors fields have special treatment, because both of these fields can hold more than one item. A book can have many tags and many authors. When you specify that one of these two fields is to be changed, the template's result is examined to see if more than one item is there. For tags, the result is cut apart wherever calibre finds a comma. For example, if the template produces the value ``Thriller, Horror``, then the result will be two tags, ``Thriller`` and ``Horror``. There is no way to put a comma in the middle of a tag.
nl: De labels en auteurs velden hebben een speciale behandeling omdat beide velden meer dan één item kunnen vasthouden. Een boek kan vele labels en meerdere auteurs hebben. Als u opgeeft dat één van deze twee velden gewijzigd gaat worden, wordt de template resultaat onderzocht om te zien of meer dan één item is. Voor labels wordt het resultaat gescheiden waar Calibre een komma vindt. Bijvoorbeeld, als de template de waarde `` Thriller, Horror`` produceert, dan zal het resultaat twee labels zijn, ``Thriller`` en ``Horror``. Er is geen manier om een komma in het midden van een tag te zetten.

en: Using functions in templates - Single Function Mode
nl: Functies gebruiken in sjablonen - Eén Functie Modus

en: Suppose you want to display the value of a field in upper case when that field is normally in title case. You can do this using `template functions`. For example, to display the title in upper case use the ``uppercase`` function, as in ``{title:uppercase()}``. To display it in title case, use ``{title:titlecase()}``.
nl: Veronderstel dat u de waarde van een veld in hoofdletters wil tonen wanneer dat veld normaal elk woord met beginhoofdletter toont. Dit kan met `sjabloonfuncties`. Bv., om de titel in hoofdletters te tonen, gebruik de ``uppercase`` functie, zoals in ``{title:uppercase()}``. Om met beginhoofdletters te tonen, gebruik ``{title:titlecase()}``.

en: Functions go into the format part of the template, after the ``:`` and before the first ``|`` or the closing ``}`` if no prefix/suffix is used. If you have both a format and a function reference, the function comes after a second ``:``.  Functions return the value of the column specified in the template, suitably modified.
nl: Functies gaan in het formaat deel van de sjabloon, na de ``:`` en voor de eerste ``|`` of de sluit ``}`` als geen voor- of achtervoegsel is gebruikt. Als u zowel een formaat als een functie referentie hebt, komt de functie na een tweede ``:``.  Functies geven de waarde terug van de kolom gespecificeerd in de sjabloon, gepast gewijzigd.

en: The syntax for using functions is one of::
nl: De syntaxis voor gebruik van functies is een van::

en: Function names must always be followed by opening and closing parentheses. Some functions require extra values (arguments), and these go inside the parentheses. Arguments are separated by commas. Literal commas (commas as text, not argument separators) must be preceded by a backslash (``\``) . The last (or only) argument cannot contain a textual closing parenthesis.
nl: Functienamen moeten altijd gevolgd worden door open/sluithaakjes. Sommige functies hebben extra waarden (argumenten) nodig en deze staan tussen de haakjes. Argumenten worden gescheiden door komma's. Letterlijke komma's (als tekst, niet als argumenten scheiders) moeten vooraf gegaan worden door een achteroverhellend streepje (``\``). Het laatste (of enige) argument kan geen tekstueel sluithaakje bevatten.

en: Functions are evaluated before format specifications and the prefix/suffix. See further down for an example of using both a format and a function.
nl: Functies worden geëvalueerd voor formaat specificaties en het voor-/achtervoegsel. Kijk verder beneden voor een voorbeeld van gebruik van zowel een formaat als een functie.

en: **Important**: If you have programming experience, please note that the syntax in `Single Function Mode` is not what you expect. Strings are not quoted and spaces are significant. All arguments are considered to be constants; there are no expressions.
nl: **Belangrijk**: Als u programmeerervaring hebt, hou er a.u.b. rekening mee dat de syntaxis in `Eén Functie Modus` niet is wat u verwacht. Strings hebben geen aanhalingstekens en spaties zijn belangrijk. Alle argumenten worden gezien als contanten; er zijn geen expressies.

en: **Do not use subtemplates (`{ ... }`) as function arguments.** Instead, use :ref:`Template Program Mode <template_mode>` and :ref:`General Program Mode <general_mode>`.
nl: **Gebruik geen subsjablonen (`{ ... }`) als functie argumenten.** In plaats daarvan, gebruik :ref:`Sjabloon Programma Modus <template_mode>` en :ref:`Algemene Programma Modus <general_mode>`.

en: **Using functions and formatting in the same template**
nl: **Functies en opmaak gebruiken in dezelfde sjabloon**

en: Suppose you have an integer custom column ``#myint`` that you want displayed with leading zeros, as in ``003``. One way to do this is to use a format of ``0>3s``. However, by default if a number (integer or float) equals zero then the value is displayed as the empty string so zero values will produce the empty string, not ``000``. If you want to see ``000`` values then you use both the format string and the ``ifempty`` function to change the empty value back to a zero. The template would be::
nl: Veronderstel, u hebt een aangepaste kolom met gehele getallen ``#myint`` die u wilt weergeven met voorloopnullen, zoals in ``003``. Een manier om dit te doen is met het formaat ``003``. Hoewel, standaard, als een getal (geheel of decimaal) gelijk is aan nul wordt de waarde getoond als de lege string dus nul waardes geven de lege string, niet ``000``. Als u ``000`` waardes wilt zien, gebruikt u zowel de formaat string als de  ``ifempty`` functie om de lege waarde terug op nul te zetten. De sjabloon wordt::

en: Note that you can use the prefix and suffix as well. If you want the number to appear as ``[003]`` or ``[000]``, then use the template::
nl: Merk op dat u zowel het voor- als het achtervoegsel kan gebruiken. Als u wil dat het getal verschijnt als ``[003]`` of ``[000]``, gebruik dan de sjabloon::

en: General Program Mode
nl: Algemene Programma Modus

en: `General Program Mode` (`GPM`) replaces `template expressions` with a program written in the `template language`. The syntax of the language is defined by the following grammar::
nl: `Algemene Programma Modus` (`APM`) vervangt `sjabloonexpressies` door een programma geschreven in de `sjabloontaal`. De syntaxis van de taal is gedefinieerd door de volgende grammatica::

en: a ``top_expression`` always has a value. The value of an ``expression_list`` is the value of the last ``top_expression`` in the list. For example, the value of the expression list ``1;2;'foobar';3`` is ``3``.
nl: een ``top_expression`` heeft altijd een waarde. De waarde van een ``expression_list`` is de waarde van de laatste ``top_expression`` in de lijst. Bv. de waarde van de expressielijst ``1;2;'foobar';3`` is ``3``.

en: In a logical context, any non-empty value is ``True``
nl: In een logische context is elke niet-lege waarde ``True``

en: In a logical context, the empty value is ``False``
nl: In een logische context is de lege waarde ``False``

en: Strings and numbers can be used interchangeably. For example, ``10`` and ``'10'`` are the same thing.
nl: Strings en getallen kunnen door elkaar gebruikt worden. Bv. ``10`` en ``'10'`` zijn identiek.

en: Comments are lines starting with a '#' character. Comments beginning later in a line are not supported.
nl: Commentaar zijn regels die beginnen met '#'. Commentaar verder in de regel wordt niet ondersteund.

en: **Operator precedence**
nl: **Operator voorrang**

en: The operator precedence (order of evaluation) from highest (evaluated first) to lowest (evaluated last) is:
nl: De operator voorrang (volgorde van evalueren) van hoogste (eerst geëvalueerd) naar laagste (laatst geëvalueerd) is:

en: Function calls, constants, parenthesized expressions, statement expressions, assignment expressions, field references.
nl: Functie aanroep, constanten, uitdrukkingen tussen haakjes, instructie-expressies, opdracht-expressies, veldreferenties.

en: Unary plus (``+``) and minus (``-``). These operators evaluate right to left.
nl: Unary plus (``+``) en min (``-``). Deze operatoren evalueren van rechts naar links.

en: These and all the other arithmetic operators return integers if the expression results in a fractional part equal to zero. For example, if an expression returns ``3.0`` it is changed to ``3``.
nl: Deze en alle andere rekenkundige operatoren geven integers terug als het resultaat van de expressie een fractioneel deel gelijk aan nul is. Bv. als een expressie ``3.0`` terug geeft, wordt dit veranderd in ``3``.

en: Multiply (``*``) and divide (``/``). These operators are associative and evaluate left to right. Use parentheses if you want to change the order of evaluation.
nl: Vermenigvuldigen (``*``) en delen (``/``). Deze operatoren zijn associatief en evalueren van links naar rechts. Gebruik haakjes als u de volgorde van evaluatie wilt veranderen.

en: Add (``+``) and subtract (``-``). These operators are associative and evaluate left to right.
nl: Optellen (``+``) en aftrekken (``-``). Deze operatoren zijn associatief en evalueren van links naar rechts.

en: Numeric and string comparisons. These operators return ``'1'`` if the comparison succeeds, otherwise the empty string (``''``). Comparisons are not associative: ``a < b < c`` is a syntax error.
nl: Numerieke en string vergelijkingen. Deze operatoren geven ``'1'`` terug als de vergelijking door gaat, anders de lege string (``''``). Vergelijkingen zijn niet associatief: ``a < b < c`` is  een syntaxis fout.

en: Unary logical not (``!``). This operator returns ``'1'`` if the expression is False (evaluates to the empty string), otherwise ``''``.
nl: Unary logisch niet (``!``). Deze operator geeft ``'1'`` terug als de expressie Vals is (evalueert naar de lege string), anders ``''``.

en: Logical and (``&&``). This operator returns '1' if both the left-hand and right-hand expressions are True, or the empty string ``''`` if either is False. It is associative, evaluates left to right, and does `short-circuiting <https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_.
nl: Logisch en (``&&``). Deze operator geeft '1' terug als zowel de linker- als de rechter-kant expressies Waar zijn, of de lege string ``''`` als een van beide Vals is. Het is associatief, evalueert van links naar rechts en doet aan `kort-sluiten <https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_.

en: Logical or (``||``). This operator returns ``'1'`` if either the left-hand or right-hand expression is True, or ``''`` if both are False. It is associative, evaluates left to right, and does `short-circuiting <https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_. It is an `inclusive or`, returning ``'1'`` if both the left- and right-hand expressions are True.
nl: Logische of (``||``). Deze operator geeft ``'1'`` terug als ofwel de linker- ofwel de rechterkant expressie Waar is, of ``''`` als beide Vals zijn. Hij is associatief, evalueert van links naar rechts en doet aan `kort-sluiten <https://chortle.ccsu.edu/java5/Notes/chap40/ch40_2.html>`_. Het is een `inclusieve of`, geeft ``'1'`` terug als zowel de linker- en rechterkant expressies Waar zijn.

en: **Field references**
nl: **Veldreferenties**

en: **If expressions**
nl: **If expressies**

en: ``If`` expressions first evaluate the ``condition``. If the ``condition`` is True (a non-empty value) then the ``expression_list`` in the ``then`` clause is evaluated. If it is False then if present the ``expression_list`` in the ``elif`` or ``else`` clause is evaluated. The ``elif`` and ``else`` parts are optional. The words ``if``, ``then``, ``elif``, ``else``, and ``fi`` are reserved; you cannot use them as identifier names. You can put newlines and white space wherever they make sense. The ``condition`` is a ``top_expression`` not an ``expression_list``; semicolons are not allowed. The ``expression_lists`` are semicolon-separated sequences of ``top_expressions``. An ``if`` expression returns the result of the last ``top_expression`` in the evaluated ``expression_list``, or the empty string if no expression list was evaluated.
nl: ``If`` expressies evalueren eerst de ``condition``. Als de ``condition`` Waar is (een niet-lege waarde) wordt de ``expression_list`` in de ``then`` clausule geëvalueerd. Als ze Onwaar is wordt, indien aanwezig, de ``expression_list`` in de ``elif`` of ``else`` clausule geëvalueerd. De ``elif`` en ``else`` delen zijn optioneel. De woorden ``if``, ``then``, ``elif``, ``else``, en ``fi`` zijn gereserveerd; U kan ze niet gebruiken als identificator namen. U kan nieuwe regels en spaties zetten overal waar het zin heeft. De ``condition`` is een ``top_expression`` geen ``expression_list``; puntkomma's zijn niet toegelaten. De ``expression_lists`` zijn puntkomma gescheiden reeksen met ``top_expressions``. Een ``if`` expressie geeft het resultaat terug van de laatste ``top_expression`` in de geëvalueerde ``expression_list``, of de lege string als geen expressie lijst werd geëvalueerd.

en: Examples::
nl: Voorbeelden::

en: Nested ``if`` example::
nl: Genest ``if`` voorbeeld::

en: As said above, an ``if`` produces a value. This means that all the following are equivalent::
nl: Zoals boven gezegd, een ``if`` geeft een waarde. Dat betekent dat al de volgenden equivalent zijn::

en: **For expressions**
nl: **For expressies**

en: Example: This template removes the first hierarchical name for each value in Genre (``#genre``), constructing a list with the new names::
nl: Voorbeeld: Deze sjabloon verwijdert de eerste hiërarchische naam voor elke waarde in Genre (``#genre``), een lijst opbouwend met de nieuwe namen::

en: If the original Genre is `History.Military, Science Fiction.Alternate History, ReadMe` then the template returns `Military, Alternate History, ReadMe`. You could use this template in calibre's :guilabel:`Edit metadata in bulk -> Search & replace` with :guilabel:`Search for` set to ``template`` to strip off the first level of the hierarchy and assign the resulting value to Genre.
nl: Als het originele Genre `History.Military, Science Fiction.Alternate History, ReadMe` is dan geeft de sjabloon `Military, Alternate History, ReadMe` terug. U kan deze sjabloon gebruiken in calibre's :guilabel:`Metadata bewerken in bulk -> Zoeken & vervangen` met :guilabel:`Zoeken naar` ingesteld op ``template`` om het eerste niveau van de hiërarchie te verwijderen en de resulterende waarde aan Genre toe te wijzen.

en: Note: the last line in the template, ``new_tags``, isn't strictly necessary in this case because ``for`` returns the value of the last top_expression in the expression list. The value of an assignment is the value of its expression, so the value of the ``for`` statement is what was assigned to ``new_tags``.
nl: Merk op: de laatste regel in de sjabloon, ``new_tags``, is niet strikt nodig in dit geval omdat ``for`` de waarde van de laatste top_expression terug geeft in de expressie lijst. De waarde van een opdracht is de waarde van zijn expressie, dus de waarde van het ``for`` bericht is wat was toegewezen aan ``new_tags``.

en: **Relational operators**
nl: **Relationele operatoren**

en: There are two forms of relational operators: string comparisons and numeric comparisons.
nl: Er zijn twee soorten relationele operatoren: string vergelijkingen en numerieke vergelijkingen.

en: The numeric comparison operators are ``==#``, ``!=#``, ``<#``, ``<=#``, ``>#``, ``>=#``. The left and right expressions must evaluate to numeric values with two exceptions: both the string value "None" (undefined field) and the empty string evaluate to the value zero.
nl: De numerieke vergelijkingsoperatoren zijn ``==#``, ``!=#``, ``<#``, ``<=#``, ``>#``, ``>=#``. De links en rechts expressies moeten evalueren naar numerieke waarden met twee uitzonderingen: zowel de string waarde "None" (niet gedefinieerd veld) en de lege string evalueren naar de waarde nul.

en: Examples:
nl: Voorbeelden:

en: ``program: 'f.o' in field('series')`` returns ``'1'`` if the book's series matches the regular expression ``f.o`` (e.g., `foo`, `Off Onyx`, etc.), otherwise ``''``.
nl: ``program: 'f.o' in field('series')`` geeft ``'1'`` terug als het boek z'n serie overeenkomt met de reguliere expressie ``f.o`` (bv., `foo`, `Off Onyx`, enz.), anders ``''``.

en: ``program: if 11 > 2 then 'yes' else 'no' fi`` returns ``'no'`` because the ``>`` operator does a lexical comparison.
nl: ``program: if 11 > 2 then 'yes' else 'no' fi`` geeft ``'no'`` omdat de ``>`` operator een lexicale vergelijking doet.

en: ``program: if 11 ># 2 then 'yes' else 'no' fi`` returns ``'yes'`` because the ``>#`` operator does a numeric comparison.
nl: ``program: if 11 ># 2 then 'yes' else 'no' fi`` geeft ``'yes'`` terug omdat de ``>#`` operator een numerieke vergelijking doet.

en: More complex programs in template expressions - Template Program Mode
nl: Meer complexe programma's in sjabloonexpressies - Sjabloon Programma Modus

en: `Template Program Mode` (`TPM`) is a blend of :ref:`General Program Mode <general_mode>` and :ref:`Single Function Mode <single_mode>`. `TPM` differs from Single Function Mode in that it permits writing template expressions that refer to other metadata fields, use nested functions, modify variables, and do arithmetic. It differs from `General Program Mode` in that the template is contained between ``{`` and ``}`` characters and doesn't begin with the word ``program:``. The program portion of the template is a General Program Mode expression list.
nl: `Sjabloon Programma Modus` (`SPM`) is een mengeling van :ref:`Algemene Programma Modus <general_mode>` en :ref:`Eén Functie Modus <single_mode>`. `TPM` verschilt van Eén Functie Modus in dat het toelaat sjabloon expressies te schrijven die verwijzen naar andere metadata velden, geneste functies gebruikt, variabelen wijzigt, en rekenkunde doet. Het verschilt van `Algemene Programma Modus` in dat de sjabloon gevat wordt tussen ``{`` en ``}`` karakters en niet begint met het woord ``program:``. Het programma deel van de sjabloon is een Algemene Programma Modus expressie lijst.

en: The example shows several things:
nl: Het voorbeeld toont meerdere dingen:

en: white space is ignored and can be used anywhere within the expression.
nl: spaties worden genegeerd en kunnen eender waar in de expressie gebruikt worden

en: constant strings are enclosed in matching quotes, either ``'`` or ``"``.
nl: constante strings zijn omringd door overeenkomende aanhalingstekens, ofwel ``'`` ofwel ``"``.

en: E-book conversion dialog
nl: E-boek conversie dialoog

en: Stored templates
nl: Opgeslagen sjablonen

en: ``foo()`` -- call the template passing no arguments.
nl: ``foo()`` -- roep de sjabloon aan zonder argumenten door te geven.

en: ``foo(a, b)`` call the template passing the values of the two variables ``a`` and ``b``.
nl: ``foo(a, b)`` roep de sjabloon aan met doorgeven van de waardes van de twee variabelen ``a`` en ``b``.

en: ``foo(if field('series') then field('series_index') else 0 fi)`` -- if the book has a ``series`` then pass the ``series_index``, otherwise pass the value ``0``.
nl: ``foo(if field('series') then field('series_index') else 0 fi)`` -- als het boek een ``series`` heeft, passeer de ``series_index``, anders de waarde ``0``.

en: Examples, again assuming the stored template is named ``foo``:
nl: Voorbeelden, er weer vanuit gaand dat de opgeslagen sjabloon ``foo`` heet:

en: ``foo('#myseries')`` -- argument ``key`` is assigned the value ``'myseries'`` and the argument ``alternate`` is assigned the default value ``'series'``.
nl: ``foo('#myseries')`` -- argument ``key`` krijgt de waarde ``'myseries'`` toegewezen en het argument ``alternate`` krijgt de standaard waarde ``'series'`` toegewezen.

en: ``foo('series', '#genre')`` the variable ``key`` is assigned the value ``'series'`` and the variable ``alternate`` is assigned the value ``'#genre'``.
nl: ``foo('series', '#genre')`` de variabele ``key`` krijgt de waarde ``'series'`` toegewezen en de variabele ``alternate`` de waarde ``'#genre'``.

en: ``foo()`` -- the variable ``key`` is assigned the empty string and the variable ``alternate`` is assigned the value ``'series'``.
nl: ``foo()`` -- de variabele ``key`` krijgt de lege string toegewezen en de variabele ``alternate`` de waarde ``'series'``.

en: Providing additional information to templates
nl: Bijkomende informatie voor sjablonen voorzien

en: **Developer: how to pass additional information**
nl: **Ontwikkelaar: hoe bijkomende informatie doorgeven**

en: **Template writer: how to access the additional information**
nl: **Sjabloon schrijver: hoe toegang krijgen tot de bijkomende informatie**

en: Differences:
nl: Verschillen:

en: The equivalent template in `TPM` is ::
nl: De soortgelijke sjabloon in `SPM` is::

en: The equivalent template in `GPM` is::
nl: De soortgelijke sjabloon in `APM` is::

en: Special notes for save/send templates
nl: Extra opmerkingen voor opslaan/versturen van sjablonen

en: To accomplish this, we:
nl: Om dit te bereiken:

en: Template function reference
nl: Sjabloon functie referenties
