calibre - en to es translation catalogue (261 entries)

en: The calibre template language
es: El lenguaje de plantillas de calibre

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:
es: El lenguaje de plantillas de calibre es un lenguaje específico de calibre que se utiliza en todo calibre para tareas como especificar rutas de archivo, dar formato a valores y calcular el valor de las columnas especificadas por el usuario. Ejemplos:

en: Specify the folder structure and file names when saving files from the calibre library to the disk or e-book reader.
es: Especifar la estructura de carpetas y los nombres de archivo al guardar archivos de la biblioteca de calibre en el disco o en el lector de libros electrónicos.

en: Define rules for adding icons and colors to the calibre book list.
es: Definir reglas para añadir iconos y colores a la lista de libros de calibre.

en: Define `virtual columns` that contain data from other columns.
es: Definir `columnas virtuales` que contienen datos de otras columnas.

en: Advanced library searching.
es: Búsqueda avanzada en la bibliotecas.

en: Advanced metadata search and replace.
es: Búsqueda y sustitución avanzada de metadatos.

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.
es: El lenguaje está construido en torno al concepto de una «plantilla», que especifica qué metadatos del libro se usan, las operaciones que se realizan sobre los metadatos y qué formato se aplica.

en: Basic templates
es: Plantillas básicas

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``::
es: Una plantilla básica consiste en una o varias ``expresiones de plantilla``. Una ``expresión de plantilla`` consiste en texto y nombres entre llaves (``{}``) que se sustituyen por los metadatos correspondientes del libro que está siendo procesado. Por ejemplo, la plantilla predeterminada de calibre para guardar libros en un dispositivo tiene 4 ``expresiones de plantilla``::

en: For the book "The Foundation" by "Isaac Asimov" the  will become::
es: Para el libro «The Foundation» de «Isaac Asimov» da lugar a::

en: The slashes are not ``template expressions`` because they are not in between ``{}``. Such text is left where it appears. For example, if the template is::
es: Las barras no son ``expresiones de plantilla`` porque no están entre ``{}``. Este tipo de texto se mantiene donde aparece. Por ejemplo, si la plantilla es::

en: then for "The Foundation" the template produces::
es: entonces para «The Foundation» la plantilla produce::

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``.
es: Una ``expresión de plantilla`` tiene acceso a todos los metadatos disponibles en calibre, incluidas las columnas personalizadas que haya creado, usando su el ``nombre de consulta`` de una columna. Para obtener el nombre de consulta de una `columna` (también llamada `campo`), pase el cursor sobre el encabezado de la columna en la lista de libros de calibre. Los nombres de consulta para las columnas personalizadas siempre empiezan por ``#``. Para columnas personalizadas de tipo serie, siempre hay un campo adicional llamado ``#nombre de consulta_index`` que es el índice de serie para el libro en la serie. Por ejemplo, si tiene una columna personalizada de serie llamada ``#miserie``, también habrá una columna llamada ``#miserie_index``. La columna de índice para la serie normal se llama ``series_index``.

en: In addition to the standard column based fields, you also can use:
es: Además de los campos basados en columnas normales, también puede usar:

en: ``{formats}`` - A list of formats available in the calibre library for a book
es: ``{formats}`` - Una lista de los formatos disponibles en la biblioteca de calibre para un libro

en: ``{identifiers:select(isbn)}`` - The ISBN of the book
es: ``{identifiers:select(isbn)}`` - El ISBN del libro

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::
es: Si un campo de metadatos para un libro determinado no está definido, entonces el campo en la plantilla se sustituye por un texto vacío (``''``). Por ejemplo, considere la siguiente plantilla::

en: If Asimov's book "Second Foundation" is in the series "Foundation" then the template produces::
es: Si el libro de Asimov «Second Foundation» está en la serie «Foundation», la plantilla produce::

en: If a series has not been entered for the book then the template produces::
es: Si no se ha introducido la serie para el libro, la plantilla produce::

en: The template processor automatically removes multiple slashes and leading or trailing spaces.
es: El procesador de plantillas elimina automáticamente barras múltiples y espacios iniciales o finales.

en: Advanced formatting
es: Formato avanzado

en: In addition to metadata substitution, templates can conditionally include additional text and control how substituted data is formatted.
es: Además de sustituir metadatos, las plantillas pueden incluir texto adicional de manera condicional y controlar el formato de los datos sustituidos.

en: **Conditionally including text**
es: **Incluir texto de mane condicional**

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.
es: A veces puede querer que aparezca un texto en la salida sólo si un campo no está vacío. Un caso común es ``series`` y ``series_index``, para los que puede querer o nada o ambos valores separados por un guión. calibre tiene en cuenta este caso usando una sintaxis de ``expresión de plantilla`` especial.

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:
es: Por ejemplo, y usando el caso anterior de la serie «Foundation», suponga que quiere que la plantilla produzca `Foundation - 3 - Second Foundation`. Esta plantilla cumple el cometido:

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:
es: Sin embargo, si un libro no tiene serie, la plantilla producirá `- - el título`, que probablemente no sea lo que deseaba. Normalmente preferiría que el resultado fuese el título sin los guiones. Puede conseguir esto usando la siguiente sintaxis de plantilla:

en: ``{field:|prefix_text|suffix_text}``
es: ``{campo:|prefijo|sufijo}``

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.
es: Esta ``expresión de plantilla`` dice que si ``campo`` tiene el valor `XXXX`, el resultado será `prefijoXXXXXsufijo`. Si ``campo`` está vacío (no tiene ningún valor) el resultado será un texto vacío (nada), porque el prefijo y el sufijo se ignoran. Tanto el prefijo como el sufijo pueden contener espacios.

en: **Do not use subtemplates (`{ ... }`) or functions (see below) in the prefix or the suffix.**
es: **No use subplantillas ({...}) o funciones (ver más adelante) en el prefijo o el sufijo.**

en: Using this syntax, we can solve the above no-series problem with the template::
es: Usando esta sintaxis, podemos resolver el problema anterior de los libros sin serie con esta plantilla::

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`.
es: Los guiones se incluirán solamente si el libro tiene índice de serie, que sólo tendrá si tiene una serie. Continuando con el ejemplo de la serie «Foundation», la plantilla producirá `Foundation - 1 - Second Foundation`.

en: Notes:
es: Notas:

en: You must include the colon after the ``lookup name`` if you are using a prefix or a suffix.
es: Debe incluir los dos puntos tras el ``nombre de consulta`` si usa un prefijo o sufijo.

en: You must either use either no or both ``|`` characters. Using one, as in ``{field:| - }``, is not allowed.
es: Debe incluir ambos caracteres ``|`` o ninguno. No está permitido usar sólo uno como en ``{campo:| - }``.

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}``.
es: Es posible asignar un texto vació para el prefijo o sufijo, como en ``{series:|| - }``. La plantilla ``{title:||}`` es lo mismo que ``{title}``.

en: **Formatting**
es: **Formato**

en: Suppose you want the ``series_index`` to be formatted as three digits with leading zeros. This does the trick:
es: Supongamos que queremos asegurarnos de que ``series_index`` aparezca con dígitos, con ceros a la izquierda. Se consigue de esta manera::

en: ``{series_index:0>3s}`` - Three digits with leading zeros
es: ``{series_index:0>3s}`` - Tres dígitos con ceros a la izquierda

en: For trailing zeros, use:
es: Para obtener ceros a la derecha use:

en: ``{series_index:0<3s}`` - Three digits with trailing zeros
es: ``{series_index:0<3s}``  - Tres dígitos con ceros a la derecha

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:
es: Si usa índices de serie con decimales (por ejemplo 1.1), puede querer asegurarse de que los decimales queden alineados. Por ejemplo, puede que los índices 1 y 2.5 aparezcan como 01.00 y 02.50 para que se ordenen correctamente en un dispositivo que utilice un orden lexicográfico. Para ello, use:

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.
es: ``{series_index:0>5.2f}`` - Cinco caracteres que incluyen dos dígitos con cero a la izquierda, un punto decimal y dos dígitos tras el punto decimal.

en: If you want only the first two letters of the data, use:
es: Si quiere sólo las dos primeras letras de los datos, use:

en: ``{author_sort:.2}`` - Only the first two letters of the author sort name
es: ``{author_sort:.2}`` - Sólo las primeras dos letras del orden de autor

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>`_.
es: Gran parte del formato del lenguaje de plantillas de calibre proviene de Python. Para obtener más detalles sobre la sintaxis de estas operaciones de formato avanzadas, vea la `documentación de Python <https://docs.python.org/3/library/string.html#formatstrings>`_ (en inglés).

en: Using templates to define custom columns
es: Usar plantillas para definir columnas personalizadas

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}``.
es: Las plantillas pueden usarse para mostrar información que no está en los metadatos de calibre o para mostrar los metadatos de una manera diferente al formato normal de calibre. Por ejemplo, puede querer mostrar el ``ISBN``, un campo que calibre no muestra. Puede conseguirlo creando una columna personalizadad de tipo `columna generada a partir de otras columnas` (en lo sucesivo llamadas `columnas compuestas`), e introduciendo una plantilla para generar el texto mostrado. La columna mostrará el resultado de evaluar la plantilla. Por ejemplo, para mostrar el ISBN, cree la columna e introduzca ``{identifiers:select(isbn)}`` en el cuadro de plantilla. Para mostrar una columna que contenga los valores de dos campos personalizados de serie separados por una coma, use ``{#serie1:||,}{#serie2}``.

en: Composite columns can use any template option, including formatting.
es: Las columnas compuestas pueden utilizar cualquier opción de plantilla, incluidas las de formato.

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.
es: Nota: No puede modificar los datos mostrados en una columna compuesta, debe modificar las columnas de origen. Si modifica una columna compuesta, por ejemplo pulsando dos veces sobre ella, calibre abrirá la plantilla para modificarla, no los datos resultantes.

en: Templates and plugboards
es: Plantillas y controles de metadatos

en: Plugboards are used for changing the metadata written into books during send-to-device and save-to-disk operations. A plugboard permits you to specify a template to provide the data to write into the book's metadata. You can use plugboards to modify the following fields: authors, author_sort, language, publisher, tags, title, title_sort. This feature helps people who want to use different metadata in books on devices to solve sorting or display issues.
es: Los paneles de conexiones se usan para cambiar los metadatos escritos en los libros durante las operaciones de guardado en disco y de envío a dispositivo. Un panel de conexiones le permite especificar una plantilla para suministrar los datos que se escribirán en los metadatos del libro. Puede usar los paneles de conexiones para modificar los siguientes campos: authors, author_sort, language, publisher, tags, title, title_sort. Esa función es útil para los que quieren usar metadatos diferentes en los libros de los dispositivos, para solucionar problemas de ordenación o de visualización.

en: When you create a plugboard, you specify the format and device for which the plugboard is to be used. A special device is provided, ``save_to_disk``, that is used when saving formats (as opposed to sending them to a device). Once you have chosen the format and device, you choose the metadata fields to change, providing templates to supply the new values. These templates are `connected` to their destination fields, hence the name `plugboards`. You can of course use composite columns in these templates.
es: Cuando cree un panel de conexiones, especifique el formato y dispositivo para los que se usará. Hay un dispositivo especial ``save_to_disk``, que se usa para guardar formatos (en lugar de enviarlos a un dispositivo). Una vez que ha elegido el formato y dispositivo, elija los campos de metadatos para cambiar, y suministre plantillas para obtener los nuevos valores. Estas plantillas están `conectadas` con sus campos de destino, de ahí el nombre `panel de conexiones`. Por supuesto, puede usar columnas compuestas en estas plantillas.

en: Plugboards are quite flexible and can be written in Single Function Mode, Template Program Mode, General Program Mode, or Python Template mode.
es: Los paneles de conexiones son muy flexibles y pueden escribirse en modo de función única, en modo programación de plantillas, en modo de programación general o en modo de plantilla de Python.

en: When a plugboard might apply (Content server, save to disk, or send to device), calibre searches the defined plugboards to choose the correct one for the given format and device. For example, to find the appropriate plugboard for an EPUB book being sent to an ANDROID device, calibre searches the plugboards using the following search order:
es: Cuando un panel de conexiones pueda aplicarse (servidor de contenido, guardado en disco o envío a dispositivo), calibre busca los paneles definidos para elegir el correcto según el formato y dispositivo. Por ejemplo, para encontrar el panel de conexiones apropiado para enviar un libro EPUB a un dispositivo ANDROID, calibre busca en los paneles en el siguiente orden:

en: a plugboard with an exact match on format and device, e.g., ``EPUB`` and ``ANDROID``
es: un panel de conexiones con una coincidencia exacta de formato y dispositivo, por ejemplo: ``EPUB`` y ``ANDROID``

en: a plugboard with an exact match on format and the special ``any device`` choice, e.g., ``EPUB`` and ``any device``
es: un panel de conexiones con una coincidencia exacta de formato y el dispositivo especial ``any device``, por ejemplo ``EPUB`` y ``any device``

en: a plugboard with the special ``any format`` choice and an exact match on device, e.g., ``any format`` and ``ANDROID``
es: un panel de conexiones con el formato especial ``any format`` y una coincidencia exacta de dispositivo, por ejemplo: ``any format`` y ``ANDROID``

en: a plugboard with ``any format`` and ``any device``
es: un panel de conexiones con ``any format`` y ``any device``

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.
es: Los campos etiquetas y autores tienen un trato especial, debido a que ambos pueden tener más de un elemento. Un libro puede poseer varias etiquetas y varios autores. Cuando indique que desea cambiar uno de estos campos, la plantilla se examina para comprobar si hay más de un elemento. Para las etiquetas, el resultado se divide dondequiera que calibre encuentre una coma. Por ejemplo, si la plantilla produce el valor ``Intriga, Terror``, el resultado serán dos etiquetas: ``Intriga`` y ``Terror``. No existe manera de poner una coma dentro de una etiqueta.

en: The same thing happens for authors, but using a different character for the cut, a `&` (ampersand) instead of a comma. For example, if the template produces the value ``Blogs, Joe&Posts, Susan``, then the book will end up with two authors, ``Blogs, Joe`` and ``Posts, Susan``. If the template produces the value ``Blogs, Joe;Posts, Susan``, then the book will have one author with a rather strange name.
es: Lo mismo ocurre con los autores, pero usando un carácter diferente para el corte, un signo «&» en lugar de una coma. Por ejemplo, si la plantilla produce el valor ``Blogs, Joe&Posts, Susan``, el libro acabará con dos autores, ``Blogs, Joe`` y ``Posts, Susan``. Si la plantilla produce el valor ``Blogs, Joe;Posts, Susan``, el libro tendrá un autor con un nombre peculiar.

en: Plugboards affect the metadata written into the book when it is saved to disk or written to the device. Plugboards do not affect the metadata used by ``save to disk`` and ``send to device`` to create the file names. Instead, file names are constructed using the templates entered on the appropriate preferences window.
es: Los paneles de conexiones afectan a los metadatos escritos en el libro cuando se guarda en disco o se escribe en un dispositivo. Los paneles de conexiones no afectan a los metadatos usados por las funciones :guilabel:`Guardar en el disco` :guilabel:`Enviar al dispositivo` para crear los nombres de archivo. En lugar de ello, los nombres de archivo se construyen usando las plantillas introducidas en la ventana de preferencias correspondiente.

en: Using functions in templates - Single Function Mode
es: Usar funciones en plantillas: modo de función única

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()}``.
es: Supongamos que desea mostrar el valor de un campo en mayúsculas, aunque normalmente el valor del campo tiene sólo las iniciales en mayúscula. Puede conseguir esto usando las `funciones de plantilla`. Por ejemplo, para mostrar el título en mayúsculas use la función ``uppercase``, como en ``{title:uppercase()}``. Para mostrarlo con las iniciales en mayúscula use ``{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.
es: Las funciones van en la parte del formato de la plantilla, después de ``:`` y antes del primer ``|`` o del ``}`` de cierre si no se usa ningún prefijo o sufijo. Si tiene tanto un formato como una referencia de función, la función va después de otro ``:``. Las funciones devuelven el valor de la columna especificada en la plantilla, modificado de manera adecuada.

en: The syntax for using functions is one of::
es: La sintaxis para usar funciones es una de::

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.
es: Los nombres de función deben is siempre seguidos de paréntesis de apertura y cierre. Algunas funciones requieren valores adicionales (argumentos), y éstos van dentro de los paréntesis. Los argumentos se separan por comas. Una coma literal (como texto, no como separador de argumentos) debe ir precedida de una barra invertida (``\``). El último (o único) argumento no puede contener un paréntesis de cierre textual.

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.
es: Las funciones se evalúan antes de las especificaciones de formato y del prefijo y sufijo. Véase más abajo un ejemplo de cómo usar un formato y una función.

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.
es: **Importante**: Si tiene experiencia en programación, tenga en cuenta que la sintaxis del `modo de función única` no es la que podría esperarse. Los textos van sin comillas y los espacios son importantes. Todos los argumentos se interpretan como constantes; no hay expresiones.

en: **Do not use subtemplates (`{ ... }`) as function arguments.** Instead, use :ref:`Template Program Mode <template_mode>` and :ref:`General Program Mode <general_mode>`.
es: **No use subplantillas ({...}) como argumentos de función.** En su lugar, use el :ref:`modo de programación de  plantilla <template_mode>` o el :ref:`modo de programación general <general_mode>`.

en: Notes on calling functions in Single Function Mode:
es: Notas sobre la ejecución de funciones en modo de función única:

en: When functions are used in Single Function Mode, the first parameter, ``value``, is automatically replaced by the content of the field specified in the template. For example, when the template ``{title:capitalize()}`` is processed, the content of the ``title`` field is passed as the parameter ``value`` to the capitalize function.
es: Cuando se usan las funciones en modo de función única, el primer parámetro, ``valor``, se sustituye automáticamente por el contenido del campo especificado en la plantilla. Por ejemplo, cuando se procesa la plantilla ``{title:capitalize()}``, el contenido del campo ``title`` se pasa como el parámetro ``valor`` a la función ``capitalize``.

en: In the function documentation, the notation ``[something]*`` means that ``something`` can be repeated zero or more times. The notation ``[something]+`` means that the ``something`` is repeated one or more times (must exist at least one time).
es: En la documentación de funciones, la notación ``[algo]*`` significa que ``algo`` puede repetirse cero o más veces. La notación ``[algo]+`` significa que ``algo`` se repite una o más veces (debe existir al menos una vez).

en: Some functions use regular expressions. In the template language regular expression matching is case-insensitive.
es: Algunas funciones usan expresiones regulares. En el lenguaje de plantillas, las expresiones regulares no distinguen entre mayúsculas y minúsculas.

en: Functions are documented in :ref:`template_functions_reference`. The documentation tells you what arguments the functions require and what the functions do. For example, here is the documentation of the :ref:`ff_ifempty` function.
es: Las funciones están documentadas en :ref:`template_functions_reference`. La documentación indica qué argumentos requieren las funciones y qué hacen. Por ejemplo, aquí está la documentación de la función :ref:`ff_ifempty`.

en: You see that the function requires two arguments, ``value`` and ``text_if_empty``. However, because we are using Single Function Mode, we omit the ``value`` argument, passing only ``text_if_empty``. For example, this template::
es: La función requiere dos argumentos, ``valor`` y ``texto_si_vacío``. Sin embargo, debido a que estamos usando el modo de función única, omitimos el argumento ``valor``, pasando sólo ``texto_si_vacío``. Por ejemplo, esta plantilla::

en: shows the tags for a book, if any. If it has no tags then it show `No tags on this book`.
es: muestra las etiquetas de un libro, si tiene alguna. Si no tiene etiquetas, muestra `No tags on this book`.

en: The following functions are usable in Single Function Mode because their first parameter is ``value``.
es: Las siguientes funciones se pueden usar en el modo de función única porque su primer parámetro es ``valor``.

en: **Using functions and formatting in the same template**
es: **Usar funciones y formato en la misma plantilla**

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::
es: Supongamos que tiene una columna personalizada con números enteros ``#myint``, que quiere mostrar con ceros a la izquierda, como en ``003``. Una posibilidad es usa como formato ``0>3s``. Sin embargo, de manera predeterminada, si un número (entero o decimal) es igual a cero, el valor se muestra como un texto vacío, así que el valor cero producirá un texto vacío, no ``000``. Si quiere ver los valores como ``000``, debe usar tanto el texto de formato como la función ``ifempty`` para cambiar el valor vacío a cero de nuevo, la plantilla sería::

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::
es: Tenga en cuenta que puede usar también prefijo y sufijo. Si desea que el número aparezca como ``[003]`` o ``[000]``, use la plantilla::

en: General Program Mode
es: Modo de programación general

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::
es: El `Modo de programación general` (`MPG`) sustituye las `expresiones de plantilla` por un programa escrito en el `lenguaje de plantillas`. La sintaxis del lenguaje está definida por la siguiente gramática::

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``.
es: una ``top_expression`` siempre tiene un valor. El valor de una ``expression_list`` es el valor de la última ``top_expression`` de la lista. Por ejemplo, el valor de la ``expression_list`` ``1;2;'blabla';3`` es ``3``.

en: In a logical context, any non-empty value is ``True``
es: En un contexto lógico, cualquier valor que no sea vacío es ``True`` (verdadero)

en: In a logical context, the empty value is ``False``
es: En un contexto lógico, el valor vacío es ``False`` (falso)

en: Strings and numbers can be used interchangeably. For example, ``10`` and ``'10'`` are the same thing.
es: Textos y números pueden usarse indistintamente. Por ejemplo, ``10`` y ``'10'`` son lo mismo.

en: Comments are lines starting with a '#' character, possibly preceded by blanks or tabs.
es: Los comentarios son líneas que empiezan por un carácter «#», posiblemente precedido por espacios o tabulaciones.

en: **Operator precedence**
es: **Prioridad de operadores**

en: The operator precedence (order of evaluation) from highest (evaluated first) to lowest (evaluated last) is:
es: La prioridad de los operadores (orden de evaluación) de mayor (se evalúa primero) a menor (se evalúa el último) es:

en: Function calls, constants, parenthesized expressions, statement expressions, assignment expressions, field references.
es: Llamadas a función, constantes, expresiones entre paréntesis, expresiones de declaración, expresiones de asignación, referencias de campo.

en: Unary plus (``+``) and minus (``-``). These operators evaluate right to left.
es: Más (``+``) y menos (``-``) unarios. Estos operadores se evalúan de derecha a izquierda.

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``.
es: Estas y todas las otras operaciones aritméticas devuelven enteros si la expresión resulta en una parte decimal igual a cero. Por ejemplo, si la expresión devuelve ``3.0`` se cambia a ``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.
es: Multiplicación (``*``) y división (``/``). Estas operaciones son asociativas y se evalúan de izquierda a derecha. Use paréntesis si quiere cambiar el orden de evaluación.

en: Add (``+``) and subtract (``-``). These operators are associative and evaluate left to right.
es: Suma (``+``) y resta (``-``). Estas operaciones son asociativas y se evalúan de izquierda a derecha.

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.
es: Comparaciones numéricas y de textos. Estas operaciones devuelven ``'1'`` si la comparación tiene éxito, en caso contrario un texto vacío (``''``). Las comparaciones no son asociativas: ``a < b < c`` es un error de sintaxis.

en: String concatenation (``&``). The ``&`` operator returns a string formed by concatenating the left-hand and right-hand expressions. Example: ``'aaa' & 'bbb'`` returns ``'aaabbb'``. The operator is associative and evaluates left to right.
es: Concatenación de textos (``&``). El operador ``&`` devuelve un texto formado por concatenación de las expresiones a su izquierda y derecha. Ejemplo: ``'aaa' & 'bbb'`` devuelve ``'aaabbb'``. El operador es asociativo y se evalúa de izquierda a derecha.

en: Unary logical not (``!``). This operator returns ``'1'`` if the expression is False (evaluates to the empty string), otherwise ``''``.
es: Negación lógica unaria (``!``). Esta operación devuelve ``'1'`` si la expresión es ``False`` (da como resultado un texto vacío), en caso contrario ``''``.

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>`_.
es: Y lógico (``&&``). Esta operación devuelve ``'1'`` si ambas expresiones a derecha e izquierda son ``True``, o un texto vacío (``''``) si alguna es ``False``. Es asociativa, se evalúa de izquierda a derecha y con cortocircuito `<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.
es: O lógico (``||``). Esta operación devuelve ``'1'`` si alguna de las expresiones a derecha e izquierda es ``True``, o un ``''`` si ambas son ``False``. Es asociativa, se evalúa de izquierda a derecha y con cortocircuito `<https://chortle.ccsu.edu/java5/Notes/chap40/ch40_8.html>`_.

en: **Field references**
es: **Referencias de campo**

en: A ``field_reference`` evaluates to the value of the metadata field named by lookup name that follows the ``$`` or ``$$``. Using ``$`` is equivalent to using the :ref:`ff_field` function. Using ``$$`` is equivalent to using the :ref:`ff_raw_field` function. Examples::
es: Un elemento de tipo ``field_reference`` (referencia de campo) se evalúa como el valor del campo de metadatos nombrado por el nombre de consulta que sigue al ``$`` o ``$$``. Usar ``$`` es equivalente a usar la función :ref:`ff_field`. Usar ``$$`` es equivalente a usar la función :ref:`ff_raw_field`. Ejemplos::

en: **If expressions**
es: **Expresiones condicionales**

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.
es: Las expresiones condicionales (``if_expression``) evalúan primero la ``condition``. Si la ``condition`` es ``True`` (un valor no vacío) entonces se evalúa ``expression_list`` en la sentencia ``then``. Si es ``False``, entonces se evalúa ``expression_list`` en la sentencia ``elif`` o ``else``, si existen. Las partes ``elif`` y ``else`` son opcionales. Las palabras ``if``, ``then``, ``elif``, ``else``  y ``fi`` están reservadas, no pueden usarse como nombres de identificador. Se pueden añadir espacios y saltos de línea donde sea conveniente. La ``condition`` es una ``top_expression``, no usa ``expression_list``, no se permite punto y coma. Los elementos de tipo ``expression_list`` son secuencias de ``top_expression`` separadas por punto y coma. Una expresión condicional devuelve el resultado de la última ``top_expression`` en la ``expression_list`` evaluada, o un texto vacío si no se evaluó ninguna ``expression_list``.

en: Examples::
es: Ejemplos::

en: Nested ``if`` example::
es: Ejemplo de ``if`` anidado::

en: As said above, an ``if`` produces a value. This means that all the following are equivalent::
es: Como se ha mencionado, un ``if`` produce un valor. Esto significa que todas las siguientes expresiones son equivalentes:

en: For example, this program returns the value of the ``series`` column if the book has a series, otherwise the value of the ``title`` column::
es: Por ejemplo, este programa devuelve el valor de la columna ``series`` si el libro tiene una serie, de lo contrario, el valor de la columna ``title``::

en: **For expressions**
es: **Expresiones de bucle**

en: The ``for`` expression iterates over a list of values, processing them one at a time. The ``list_expression`` must evaluate either to a metadata field ``lookup name`` e.g., ``tags`` or ``#genre``, or to a list of values. The :ref:`ff_range` generates a list of numbers. If the result is a valid ``lookup name`` then the field's value is fetched and the separator specified for that field type is used. If the result isn't a valid lookup name then it is assumed to be a list of values. The list is assumed to be separated by commas unless the optional keyword ``separator`` is supplied, in which case the list values must be separated by the result of evaluating the ``separator_expr``. A separator cannot be used if the list is generated by ``range()``. Each value in the list is assigned to the specified variable then the ``expression_list`` is evaluated. You can use ``break`` to jump out of the loop, and ``continue`` to jump to the beginning of the loop for the next iteration.
es: Una expresión de bucle (``for_expression``) itera sobre una lista de valores, procesando uno cada vez. La ``list_expression`` debe resultar en el ``nombre de consulta`` de un campo de metadatos, como ``tags`` o ``#genero``, o una lista de valores. La función :ref:`ff_range` genera una lista de números. Si el resultado es un ``nombre de consulta`` válido, se obtiene el valor del campo y se usa el separador especificado para ese tipo de campo. Si el resultado no es un ``nombre de consulta`` válido, se supone que es una lista de valores. La lista se supone separada por comas, a no ser que use la palabra clave opcional ``separator``, en ese caso los valores de la lista deben estar separados por el resultado de evaluar ``separator_expr``. No se puede usar un separador si la lista es generada por ``range()``. Cada valor de la lista se asigna a la variable especificada y luego se evalúa ``expression_list``. Puede usar ``break`` para salir del bucle y ``continue`` para comenzar con la siguiente iteración.

en: Example: This template removes the first hierarchical name for each value in Genre (``#genre``), constructing a list with the new names::
es: Ejemplo: Esta plantilla elimina el primer nombre jerárquico para cada valor de Género (``#genre```), construyendo una lista con los nuevos nombres.

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.
es: Si el Género original es `Historia.Militar, Ciencia ficción.Historia alternativa, Léeme`, la plantilla devolverá `Militar, Historia alternativa, Léeme`. Puede usar esta plantilla en :guilabel:`Modificar metadatos en masa > Buscar y sustituir` con :guilabel:`Buscar` establecido en ``plantilla`` para eliminar el primer nivel de la jerarquía y asignar el valor resultante a Género.

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``.
es: Nota: la última línea en la plantilla, ``new_tags``, no es estrictamente necesaria en este caso, porque ``for`` devuelve el valor de la última ``top_expression`` en ``expression_list``. El valor de una asignación (``assignment``) es el valor de su expresión, así que el valor del ``for`` es lo que se asignó a ``new_tags``.

en: **Return stmt**
es: **Instrucción de retorno**

en: Return the value of the ``expression``. If executed in a function then it returns the value of the expression to the caller. If executed in the outermost context (the template) then it sets the value of the template to the value of the expression and exits the template.
es: Devuelve el valor de la ``expression``. Si se ejecuta en una función, devuelve el valor de la expresión a quien la llamó. Si se ejecuta en el contexto más externo (la plantilla), asigna el valor de la expresión como el valor de la plantilla y sale de la plantilla.

en: **Function definition**
es: **Definición de funciones**

en: If you have repeated code in a template then you can put that code into a local function. The ``def`` keyword starts the definition. It is followed by the function name, the argument list, then the code in the function. The function definition ends with the ``fed`` keyword.
es: Si tiene código repetido en una plantilla, puede poner ese código en una función local. La palabra clave ``def`` comienza la definición. Le sigue el nombre de la función, la lista de argumentos y el código en la función. La definición de función termina con la palabra clave ``fed``.

en: Arguments are positional. When a function is called the supplied arguments are matched left to right against the defined parameters, with the value of the argument assigned to the parameter. It is an error to provide more arguments than defined parameters. Parameters can have default values, such as ``a = 25``. If an argument is not supplied for that parameter then the default value is used, otherwise the parameter is set to the empty string.
es: Los argumentos son posicionales. Cuando se invoca una función, los argumentos proporcionados se hacen corresponder de izquierda a derecha con los parámetros definidos, con el valor del argumento asignado al parámetro. Es un error proporcionar más argumentos que parámetros definidos. Los parámetros pueden tener valores predeterminados, como ``a = 25``. Si no se proporciona un argumento para un parámetro, se usará el valor predeterminado, en caso contrario el parámetro será un texto vacío.

en: The ``return`` statement can be used in a local function.
es: La instrucción ``return`` se puede usar en una función local.

en: A function must be defined before it can be used.
es: Una función debe definirse antes de poder usarse.

en: Example: This template computes an approximate duration in years, months, and days from a number of days. The function ``to_plural()`` formats the computed values. Note that the example also uses the ``&`` operator::
es: Ejemplo: Esta plantilla calcula una duración aproximada en años, meses y días a partir de un número de días. La función ``to_plural()`` da formato a los valores calculados. Tenga en cuenta que el ejemplo también usa el operador ``&``::

en: **Relational operators**
es: **Operadores de relación**

en: Relational operators return ``'1'`` if the comparison is true, otherwise the empty string (``''``).
es: Los operadores de relación devuelven ``'1'`` si la comparación es cierta, en caso contrario devuelven un texto vacío (``''``).

en: There are two forms of relational operators: string comparisons and numeric comparisons.
es: Hay dos formas de operadores de relación: comparaciones de texto y comparaciones numéricas.

en: String comparisons do case-insensitive string comparison using lexical order. The supported string comparison operators are ``==``, ``!=``, ``<``, ``<=``, ``>``, ``>=``, ``in``, ``inlist``, and ``inlist_field``. For the ``in``, ``inlist``, and ``inlist_field`` operators, the result of the left hand expression is interpreted as a regular expression pattern. They are true if the value of left-hand regular expression matches the value of the right hand expression. The regular expressions are case-insensitive.
es: Las comparaciones de texto usan el orden lexicográfico y no distinguen mayúsculas y minúsculas. Las comparaciones de texto permitidas son ``==``, ``!=``, ``<``, ``<=``, ``>``, ``>=``, ``in``, ``inlist`` e ``inlist_field``. Para los operadores ``in``, ``inlist`` e ``inlist_field``, el resultado de la expresión de la izquierda se interpreta como un patrón de expresión regular. El resultado es ``True`` si el valor de la expresión regular de la izquierda coincide con el valor de la expresión de la derecha. Las expresiones regulares no distinguen mayúsculas y minúsculas.

en: The ``inlist`` operator is true if the left hand regular expression matches any one of the items in the right hand list where the items in the list are separated by commas. The ``inlist_field`` operator is true if the left hand regular expression matches any of the items in the field (column) named by the right hand expression, using the separator defined for the field. NB: the ``inlist_field`` operator requires the right hand expression to evaluate to a field name, while the ``inlist`` operator requires the right hand expression to evaluate to a string containing a comma-separated list. Because of this difference, ``inlist_field`` is substantially faster than ``inlist`` because no string conversions or list constructions are done.
es: El operador ``inlist`` es ``True`` si la expresión regular de la izquierda coincide con alguno de los elementos de la lista de la derecha, en la que los elementos están separados por comas. El operador ``inlist_field`` es ``True`` si la expresión regular de la izquierda coincide con alguno de los elementos del campo (columna) nombrado por la expresión de la derecha, usando el separador definido para el campo. Nota: el operador ``inlist_field`` requiere que la expresión de la derecha resulte en un nombre de campo, mientras que el operador ``inlist`` requiere que la expresión de la derecha resulte en un texto que contenga una lista separada por comas. Debido a esta diferencia, ``inlist_field`` es bastante más rápido que ``inlist`` porque no implica conversiones de texto o construcciones de listas.

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.
es: Los operadores de comparación numérica son ``==#``, ``!=#``, ``<#``, ``<=#``, ``>#`` y ``>=#``. Las expresiones de la izquierda y la derecha deben resultar en valores numéricos con dos excepciones: Tanto el valor textual ``None`` (campo no definido) como el texto vacío equivalen al valor cero.

en: Examples:
es: Ejemplos:

en: ``program: field('series') == 'foo'`` returns ``'1'`` if the book's series is `foo`, otherwise ``''``.
es: ``program: field('series') == 'lala'`` devuelve ``'1'`` si la serie del libro es `lala`, en caso contrario devuelve ``''``.

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 ``''``.
es: ``program: 'l.a' in field('series')`` devuelve ``'1'`` si la serie del libro coincide con la expresión regular ``l..a`` (por ejemplo, `lala`, `El asesino de reyes`, etc.), en caso contrario devuelve ``''``.

en: ``program: 'science' inlist $#genre`` returns ``'1'`` if any of the values retrieved from the book's genres match the regular expression ``science``, e.g., `Science`, `History of Science`, `Science Fiction` etc., otherwise ``''``.
es: ``program: 'ciencia' inlist $#genero` devuelve ``'1'`` si alguno de los valores obtenidos de los géneros del libro coincide con la expresión regular ``ciencia`` (por ejemplo `Ciencia`, `Historia de la ciencia`, `Ciencia ficción`, etc.), en caso contrario devuelve ``''``.

en: ``program: '^science$' inlist $#genre`` returns ``'1'`` if any of the book's genres exactly match the regular expression ``^science$``, e.g., `Science`, otherwise ``''``. The genres `History of Science` and `Science Fiction` don't match.
es: ``program: '^ciencia$' inlist $#genero`` devuelve ``'1'`` si alguno de los géneros del libro coincide con la expresión regular ``^ciencia$`` (por ejemplo `Ciencia`). Los géneros `Historia de la ciencia` y `Ciencia ficción` no coinciden.

en: ``program: 'asimov' inlist $authors`` returns ``'1'`` if any author matches the regular expression ``asimov``, e.g., `Asimov, Isaac` or `Isaac Asimov`, otherwise ``''``.
es: ``program: 'asimov' inlist $authors`` devuelve ``'1'`` si algún autor coincide con la expresión regular ``asimov`` (por ejemplo `Asimov, Isaac` o `Isaac Asimov`), en caso contrario devuelve ``''``.

en: ``program: 'asimov' inlist_field 'authors'`` returns ``'1'`` if any author matches the regular expression ``asimov``, e.g., `Asimov, Isaac` or `Isaac Asimov`, otherwise ``''``.
es: ``program: 'asimov' inlist_field 'authors'`` devuelve ``'1'`` si algún autor coincide con la expresión regular ``asimov`` (por ejemplo `Asimov, Isaac` o `Isaac Asimov`), en caso contrario devuelve ``''``.

en: ``program: 'asimov$' inlist_field 'authors'`` returns ``'1'`` if any author matches the regular expression ``asimov$``, e.g., `Isaac Asimov`, otherwise ``''``. It doesn't match `Asimov, Isaac` because of the ``$`` anchor in the regular expression.
es: ``program: 'asimov$' inlist_field 'authors'`` devuelve ``'1'`` si algún autor coincide con la expresión regular ``asimov$`` (por ejemplo `Isaac Asimov`), en caso contrario devuelve ``''``. No coincide con `Asimov, Isaac` debido al punto de anclaje ``$`` en la expresión regular.

en: ``program: if field('series') != 'foo' then 'bar' else 'mumble' fi`` returns ``'bar'`` if the book's series is not `foo`. Otherwise it returns ``'mumble'``.
es: ``program: if field('series') != 'lala' then 'nana' else 'blabla' fi`` devuelve ``'nana'`` si la serie del libro no es `lala`, en caso contrario devuelve ``'blabla'``.

en: ``program: if field('series') == 'foo' || field('series') == '1632' then 'yes' else 'no' fi`` returns ``'yes'`` if series is either `foo` or `1632`, otherwise ``'no'``.
es: ``program: if field('series') == 'lala' || field('series') == '1632' then 'sí' else 'no' fi`` devuelve ``'sí'`` si la serie es `lala` o `1632`, en caso contrario devuelve ``'no'``.

en: ``program: if '^(foo|1632)$' in field('series') then 'yes' else 'no' fi`` returns ``'yes'`` if series is either `foo` or `1632`, otherwise ``'no'``.
es: ``program: if '^(lala|1632)$' in field('series') then 'sí' else 'no' fi`` devuelve ``'sí'`` si la serie es `lala` o `1632`, en caso contrario devuelve ``'no'``.

en: ``program: if 11 > 2 then 'yes' else 'no' fi`` returns ``'no'`` because the ``>`` operator does a lexical comparison.
es: ``program: if 11 > 2 then 'sí' else 'no' fi`` devuelve ``'no'`` porque el operador ``>`` realiza una comparación lexicográfica.

en: ``program: if 11 ># 2 then 'yes' else 'no' fi`` returns ``'yes'`` because the ``>#`` operator does a numeric comparison.
es: ``program: if 11 ># 2 then 'sí' else 'no' fi`` devuelve ``'sí'`` porque el operador ``>#`` realiza una comparación numérica.

en: **Functions in General Program Mode**
es: **Funciones en modo de programación general**

en: See :ref:`template_functions_reference` for the list of functions built into the template language.
es: Consulte :ref:`template_functions_reference` para ver la lista de funciones predefinidas en el lenguaje de plantillas.

en: As opposed to :ref:`Single Function Mode <single_mode>`, in General Program Mode you must specify the first parameter ``value``.
es: A diferencia del :ref:`modo de función única <single_mode>`, en el modo de programación general debe especificar el primer parámetro ``valor``.

en: All parameters are expression_lists (see the grammar above).
es: Todos los parámetros son elementos de tipo ``expression_list`` (ver la gramática más arriba).

en: More complex programs in template expressions - Template Program Mode
es: Programas más complejos en expresiones de plantilla: modo de programación de plantillas

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.
es: El `modo de programación de plantillas` (`MPP`) es una mezcla entre el :ref:`modo de programación general <general_mode>` y el :ref:`modo de función única <single_mode>`. El `MPP` se diferencia del `modo de función única` en que permite escribir expresiones de plantilla que hacen referencia a otros campos de metadatos, usar funciones anidadas, modificar variables y hacer operaciones aritméticas. Se diferencia del `modo de programación general` en que la plantilla está entre caracteres ``{`` y ``}`` y no empieza por la palabra ``program``. La parte del programa de la plantilla es una ``expression_list`` del `modo de programación general`.

en: Example: assume you want a template to show the series for a book if it has one, otherwise show the value of a custom field #genre. You cannot do this in the :ref:`Single Function Mode <single_mode>` because you cannot make reference to another metadata field within a template expression. In `TPM` you can, as the following expression demonstrates::
es: Un ejemplo: supongamos que quiere una plantilla que muestre la serie de un libro si la tiene, y en caso contrario muestre el valor del campo personalizado ``#genre``. Esto no se puede hacer en el :ref:`modo de función única <single_mode>`, porque no se puede hacer referencia a otro campo en la expresión de la plantilla. En el `MPP` sí se puede. La siguiente expresión lo demuestra::

en: The example shows several things:
es: El ejemplo muestra varias cosas:

en: `TPM` is used if the expression begins with ``:'`` and ends with ``'}``. Anything else is assumed to be in :ref:`Single Function Mode <single_mode>`.
es: El `MPP` se usa si la expresión empieza por ``:'`` y termina en ``'}``. Cualquier otra cosa se supone que corresponde al :ref:`modo de función única <single_mode>`.

en: If the template contains a prefix and suffix, the expression ends with ``'|`` where the ``|`` is the delimiter for the prefix. Example::
es: Si la plantilla contiene un prefijo y un sufijo, la expresión termina con ``'|`` donde ``|`` es el delimitador para el prefijo. Ejemplo::

en: Functions must be given all their arguments. For example, the standard built-in functions must be given the initial parameter ``value``.
es: Las funciones deben llevar todos sus argumentos. Por ejemplo, las funciones estándar predefinidas deben tener el parámetro inicial ``valor``.

en: The variable ``$`` is usable as the ``value`` argument and stands for the value of the field named in the template, ``series`` in this case.
es: La variable ``$`` se puede usar como el argumento ``valor`` y representa el valor del campo nombrado en la plantilla, ``series`` en este caso.

en: white space is ignored and can be used anywhere within the expression.
es: los espacios en blanco se ignoran y se pueden utilizar en cualquier lugar dentro de la expresión.

en: constant strings are enclosed in matching quotes, either ``'`` or ``"``.
es: los textos constantes se encierran en comillas del mismo tipo, ya sea ``'`` o ``"``.

en: In `TPM`, using ``{`` and ``}`` characters in string literals can lead to errors or unexpected results because they confuse the template processor. It tries to treat them as template expression boundaries, not characters. In some but not all cases you can replace a ``{`` with ``[[`` and a ``}`` with `]]`. Advice: if your program contains ``{`` and ``}`` characters then you should use `General Program Mode`.
es: En el `MPP`, usar los caracteres ``{`` y ``}`` en textos literales puede conducir a errores o resultados inesperados porque confunden al procesador de plantillas. Éste intenta interpretarlos como límites de expresiones de plantilla y no como caracteres. En algunos casos, pero no todos, puede sustituir un ``{`` por ``[[`` y un ``}`` por ``]]``. Consejo: si el programa contiene caracteres ``{`` y ``}``, es mejor usar el `modo de programación general`.

en: Python Template Mode
es: Modo de plantilla de Python

en: Python Template Mode (PTM) lets you write templates using native Python and the `calibre API <https://manual.calibre-ebook.com/develop.html#api-documentation-for-various-parts-of-calibre>`_. The database API will be of most use; further discussion is beyond the scope of this manual. PTM templates are faster and can do more complicated operations but you must know how to write code in Python using the calibre API.
es: El modo de plantilla de Python (MPPy) le permite escribir plantillas usando el lenguaje Python nativo y la `interfaz de programación de calibre <https://manual.calibre-ebook.com/develop.html#api-documentation-for-various-parts-of-calibre>`_. La interfaz de programación de base de datos será la más útil, pero en este manual no se discutirán más detalles. Las plantillas MPPy son más rápidas y pueden realizar operaciones más complicadas, pero debe saber escribir código Python usando la interfaz de programación de calibre.

en: A PTM template begins with:
es: Una plantilla MPPy empieza por:

en: You can add the above text to your template using the context menu, usually accessed with a right click. The comments are not significant and can be removed. You must use python indenting.
es: Puede añadir el texto anterior a la plantilla usando el menú contextual, al que normalmente se accede pulsando el botón derecho. Los comentarios no son importantes y pueden eliminarse. Debe usar la sangría de Python.

en: The context object supports ``str(context)`` that returns a string of the context's contents, and ``context.attributes`` that returns a list of the attribute names in the context.
es: El objeto de contexto admite ``str(context)``, que devuelve un texto con el contenido del contexto y ``context.attributes``, que devuelve una lista con los nombres de los atributos del contexto.

en: The ``context.funcs`` attribute allows calling Built-in and User template functions, and Stored GPM/Python templates, so that you can execute them directly in your code. The functions are retrieved using their names. If the name conflicts with a Python keyword, add an underscore to the end of the name. Examples:
es: El atributo ``context.funcs`` le permite invocar funciones incorporadas y de usuario, así como plantillas guardadas MPG o Python, de manera que puede ejecutarlas directamente en el código. Las funciones se identifican por sus nombres. Si el nombre entra en conflicto con una palabra clave de Python, añada un guión bajo al final. Ejemplos:

en: Here is an example of a PTM template that produces a list of all the authors for a series. The list is stored in a `Column built from other columns, behaves like tags`. It shows in :guilabel:`Book details` and has the :guilabel:`on separate lines` checked (in :guilabel:`Preferences->Look & feel->Book details`). That option requires the list to be comma-separated. To satisfy that requirement the template converts commas in author names to semicolons then builds a comma-separated list of authors. The authors are then sorted, which is why the template uses author_sort.
es: He aquí un ejemplo de una plantilla MPPy que genera una lista de todos los autores de una serie. La lista se guarda en una `Columna generada a partir de otras columnas, funciona como etiquetas`. Se muestra en los :guilabel:`detalles del libro` y tiene la opción :guilabel:`en líneas separadas` activada (en :guilabel:`Preferencias > Apariencia > Detalles del libro`). Esta opción requiere que la lista esté separada por comas. Para satisfacer este requisito la plantilla convierte las comas en los nombres de autor a punto y coma y luego construye una lista de autores separados por comas. Los autores se ordenan, razón por la cual la plantilla usa author_sort.

en: The output in :guilabel:`Book details` looks like this:
es: La salida en los :guilabel:`detalles del libro` tiene este aspecto:

en: E-book conversion dialog
es: Diálogo de conversión de libros electrónicos

en: Templates and URLs
es: Plantillas y URL

en: You can use templates to construct URLs. Two cases are described here:
es: Puede usar plantillas para generar URL. Se describen dos casos a continuación:

en: Custom column :guilabel:`Book details` search URLs
es: URL de búsqueda para columnas personalizadas en :guilabel:`Detalles del libro`

en: The calibre URL scheme
es: El esquema de URL de calibre

en: **Custom column book details search URLs**
es: **URL de búsqueda para columnas personalizadas en detalles del libro**

en: When you create a custom column you can provide a URL to be used in :guilabel:`Book details` using a template. For example, if you have a custom column for `Translators` you can define a URL to take you to a site for translators. Book details search URLs can be provided for `Text`, `Enumerated`, `Series`, and `Column built from other column` column types.
es: Cuando crea una columna personalizada, puede proporcionar un URL para usar en :guilabel:`Detalles del libro` usando una plantilla. Por ejemplo, si tiene una columna personalizada para `Traductores` puede definir un URL que lleve a una página de traductores. Los URL de búsqueda de detalles del libro pueden proporcionarse para tipos de columna de `Texto`, `Enumerado`, `Serie` y `Columna generada a partir de otras columnas`.

en: When an item with a `search template` is clicked in :guilabel:`Book details` the template is evaluated. It is provided the normal book metadata. It is also provided three additional fields:
es: Cuando se pulsa sobre un elemento con una `plantilla de búsqueda` en :guilabel:`Detalles del libro`, se evalúa la plantilla. Se le suministran los metadatos normales del libro. También se le suministran tres campos adicionales:

en: ``item_value``: the value of the clicked item.
es: ``item_value``: el valor del elemento sobre el que se pulsa.

en: ``item_value_quoted``: the value of clicked item, URL-encoded. Special characters are escaped to make them valid in URLs and spaces are replaced by ``'+'`` (plus) signs.
es: ``item_value_quoted``. El valor del elemento sobre el que se pulsa, codificado para URL. Los caracteres especiales se escapan para que sean válidos en un URL y los espacios se sustituyen por signos ``+`` (más).

en: ``item_value_no_plus``: the value of clicked item, URL-encoded. Special characters are escaped to make them valid in URLs and spaces are replaced by the ``%20``, not plus.
es: ``item_value_no_plus``. El valor del elemento sobre el que se pulsa, codificado para URL. Los caracteres especiales se escapan para que sean válidos en un URL y los espacios se sustituyen por ``%20``, no signos más.

en: There are several ways to construct the URL. The following use Wikipedia as an example.
es: Hay varias maneras de generar el URL. A continuación se usa Wikipedia como un ejemplo.

en: The simplest is a basic template::
es: Lo más sencillo es una plantilla básica::

en: In some cases you might want to do more processing. There are four template functions you can use, depending on the complexity of the processing.
es: En algunos casos puede querer hacer algún procesado. Hay cuatro funciones de plantilla que puede usar, según la complejidad del procesado.

en: For example, assume you have a custom column `Translators` (``#translators``) where the names are `Last name, First name`. You might need to convert the name to `First name Last name` when creating the URL. You can use the :ref:`ff_make_url` function to do this::
es: Por ejemplo, supongamos que tiene una columna personalizada `Traductores` (``#traductores``) en la que los nombres son de la forma `Apellidos, Nombre``. Puede que tenga que convertir el nombre a `Nombre Apellidos` al crear el URL. Puede usar la función :ref:`ff_make_url` para hacerlo::

en: If we assume that the translator's name is `Boy-Żeleński, Tadeusz` then the above template produces the link::
es: Si el nombre del traductor es `Boy-Żeleński, Tadeusz`, la plantilla anterior produce el enlace::

en: Note that the person's first name is now first, the space is now a plus, and that the non-English characters in the last name are URL-encoded.
es: Advierta que el nombre de pila aparece ahora primero, el espacio es un signo más y los caracteres acentuados del apellido están codificados para URL.

en: The functions :ref:`ff_make_url_extended`, :ref:`ff_query_string`, and :ref:`ff_encode_for_url` might be useful depending upon any additional processing complexity.
es: Las funciones :ref:`ff_make_url_extended`, :ref:`ff_query_string` y :ref:`ff_encode_for_url` pueden ser útiles dependiendo de la complejidad adicional del procesado.

en: **The calibre URL scheme**
es: **El esquema de URL de calibre**

en: Calibre supports several different URLs to navigate your calibre libraries. This section shows how to use templates to construct some of the URLs. See :doc:`url_scheme` for details on the URLs available.
es: Calibre admite distintos tipos de URL para explorar las bibliotecas. Esta sección le muestra cómo usar plantillas para generar algunos de los URL. Vea :doc:`url_scheme` para más detalles sobre los URL disponibles.

en: Switch to a specific library. The syntax of this URL is::
es: Cambiar a una biblioteca específica. La sintaxis de este URL es::

en: ``Library_Name`` must be replaced with the name of the calibre library you wish to open. The library name is shown in the title bar of the window. It is a simple name, not the file path to the library. You must spell it as shown in the title bar, including letter case. The character ``_`` (underscore) stands for the current library. If the name contains any spaces or special characters then it must be hex encoded using the :ref:`ff_to_hex` function, as in the following example::
es: ``Library_Name`` debe sustituirse por el nombre de la biblioteca de calibre que quiera abrir. El nombre de la biblioteca se muestra en la barra de título de la ventana. Es un nombre simple, no la ruta de la biblioteca. Debe escribirlo tal como se muestra en la barra de título, respetando mayúsculas y minúsculas. El carácter ``_`` (guión bajo) representa la biblioteca actual. Si el nombre contiene espacios o caracteres especiales, deberá codificarse con la función :ref:`ff_to_hex` como en el siguiente ejemplo::

en: The template generates the URL::
es: La plantilla genera el URL::

en: You can replace the ``current_library_name()`` function with the actual name of the library, as in::
es: Puede sustituir la función ``current_library_name()`` por el nombre real de la biblioteca, como en::

en: Links to show books. These links select a book in the calibre library. The syntax for this URL is::
es: Enlaces para mostrar libros. Estos enlaces seleccionan un libro en la biblioteca de calibre. La sintaxis para este URL es::

en: The ``book id`` is the numeric calibre id for the book, available to templates as ``$id``. As above, the library name might need to be hex encoded. Here is an example::
es: El ``book_id`` es el identificador numérico de calibre para el libro, disponible en las plantillas como ``$id``. Como anteriormente, el nombre de la biblioteca puede tener que ser codificado como hexadecimal. He aquí un ejemplo::

en: It produces the URL::
es: Produce el URL::

en: Searching for books. These links search for books in the specified calibre library. The syntax for this URL is::
es: Buscar libros: Estos enlaces buscan libros en la biblioteca de calibre especificada. La sintaxis para este URL es::

en: where `query` is any valid calibre search expression. You must hex encode any query containing spaces or special characters, which generally means all of them. For example, the calibre search expression for searching for a hierarchical tag beginning with 'AA' is ``tags:"=.AA"``. This template constructs a search URL for that expression::
es: Donde ``query`` es cualquier expresión de búsqueda válida de calibre. Deberá codificar como hexadecimal cualquier consulta que contenga espacios o caracteres especiales, generalmente todas. Por ejemplo, la expresión de búsqueda de calibre para buscar una etiqueta jerárquica que empiece por 'AA' es ``tags:"=.AA"``. Esta plantilla genera un URL de búsqueda para dicha expresión::

en: The resulting URL is::
es: El URL resultante es::

en: Here is an example of the same URL built using the :ref:``ff_make_url_extended`` function instead of :ref:`ff_strcat`::
es: Aquí se muestra un ejemplo que genera el mismo URL usando la función ref:``ff_make_url_extended`` en lugar de :ref:`ff_strcat`::

en: Open a book details window on a book in some library. The syntax for this URL is::
es: Abrir una ventana de detalles del libro para un libro en alguna biblioteca. La sintaxis para este URL es::

en: An example template is::
es: Una plantilla de ejemplo es::

en: which produces the URL::
es: que produce el URL::

en: Open the notes associated with an author/series/etc. The syntax of the URL is::
es: Abrir las notas asociadas con un autor, serie, etc. La sintaxis del URL es::

en: ``Field_Name`` is the lookup name of the field. If the field is a custom column then replace the ``#`` character with an underscore (``_``). ``Item_Id`` is the internal numeric ID of the value in the field. There isn't a template function that returns the ``Item_Id``, so templates will normally use the second form, ``Hex_Encoded_Item_Name``. Here is a sample template that opens the note for the person ``Boy-Żeleński, Tadeusz`` in the field ``#authtest``::
es: ``Field_Name`` es el nombre de consulta del campo. Si el campo es una columna personalizada, sustituya el carácter ``#`` por un guión bajo (``_``). ``Item_Id`` es el identificador numérico interno del valor del campo. No existe una función de plantilla que devuelva el ``Item_Id``, por lo que las plantillas normalmente usarán la segunda forma, ``Hex_Encoded_Item_Name``. Esta plantilla de muestra abre la nota para el nombre ``Boy-Żeleński, Tadeusz`` en el campo ``#authtest``::

en: Stored templates
es: Plantillas guardadas

en: Both :ref:`General Program Mode <general_mode>` and :ref:`Python Template Mode <python_mode>` support saving templates and calling those templates from another template, much like calling stored functions. You save templates using :guilabel:`Preferences->Advanced->Template functions`. More information is provided in that dialog. You call a template the same way you call a function, passing positional arguments if desired. An argument can be any expression. Examples of calling a template, assuming the stored template is named ``foo``:
es: El :ref:`modo de programación general <general_mode>` y el :ref:`modo de plantilla de Python <python_mode>` permiten guardar plantillas e invocarlas desde otra plantilla, casi como invocar funciones guardadas. Puede guardar plantillas en :guilabel:`Preferencias > Avanzado > Funciones de plantilla`. Hay más información en el diálogo correspondiente. Puede invocar una plantilla de la misma manera que una función, pasando argumentos por posición si lo desea. Un argumento puede ser una expresión. Ejemplos para invocar una plantilla, suponiendo que la plantilla guardada se llame ``foo``:

en: ``foo()`` -- call the template passing no arguments.
es: ``lala()`` -- invoca la plantilla sin pasar argumentos.

en: ``foo(a, b)`` call the template passing the values of the two variables ``a`` and ``b``.
es: ``lala(a, b)`` -- invoca la plantilla pasando los valores de las variables ``a`` y ``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``.
es: ``lala(if field('series') then field('series_index') else 0 fi)`` -- si el libro tiene ``series``, pasa el valor de ``series_index``, en caso contrario pasa el valor ``0``.

en: In GPM you retrieve the arguments passed in the call to the stored template using the ``arguments`` function. It both declares and initializes local variables, effectively parameters. The variables are positional; they get the value of the parameter given in the call in the same position. If the corresponding parameter is not provided in the call then ``arguments`` assigns that variable the provided default value. If there is no default value then the variable is set to the empty string. For example, the following ``arguments`` function declares 2 variables, ``key``, ``alternate``::
es: En el MPG, puede obtener el valor de los argumentos pasados en la invocación de la plantilla guardada usando la función ``arguments``. Esta función declara e inicializa las variables locales, parámetros en la práctica. Las variables son posicionales: obtienen el valor del argumento usado en la misma posición en la invocación. Si el argumento correspondiente no aparece en la invocación, ``arguments`` asigna a esa variable el valor predeterminado suministrado. Si no hay valor predeterminado, será un texto vacío. Por ejemplo, la siguiente función ``arguments`` declara dos variables: ``key`` y ``alternate`::

en: Examples, again assuming the stored template is named ``foo``:
es: Ejemplos, suponiendo de nuevo que la plantilla guardada se llame ``lala``:

en: ``foo('#myseries')`` -- argument ``key`` is assigned the value ``'myseries'`` and the argument ``alternate`` is assigned the default value ``'series'``.
es: ``lala('#miserie')`` -- a la variable ``key`` se le asigna el valor ``'#miserie'`` y a la variable ``alternate`` se le asigna el valor predeterminado ``'serie'``.

en: ``foo('series', '#genre')`` the variable ``key`` is assigned the value ``'series'`` and the variable ``alternate`` is assigned the value ``'#genre'``.
es: ``lala('series', '#genero')`` a la variable ``key`` se le asigna el valor ``'series'`` y a la variable ``alternate`` se le asigna el valor ``'#genero'``.

en: ``foo()`` -- the variable ``key`` is assigned the empty string and the variable ``alternate`` is assigned the value ``'series'``.
es: ``lala()`` -- a la variable ``key`` se le asigna un texto vacío y a la variable ``alternate`` se le asigna el valor predeterminado ``'series'``.

en: In PTM the arguments are passed in the ``arguments`` parameter, which is a list of strings. There isn't any way to specify default values. You must check the length of the ``arguments`` list to be sure that the number of arguments is what you expect.
es: En el MPPy los argumentos se pasan en el parámetro ``arguments``, que es una lista de textos. No existe la posibilidad de especificar valores predeterminados. Debe comprobar la longitud de la lista ``arguments`` para asegurarse de que el número de argumentos es el esperado.

en: An easy way to test stored templates is using the ``Template tester`` dialog. For ease of access give it a keyboard shortcut in :guilabel:`Preferences->Advanced->Keyboard shortcuts->Template tester`. Giving the ``Stored templates`` dialog a shortcut will help switching more rapidly between the tester and editing the stored template's source code.
es: Una buena manera de probar las plantillas guardadas es usar el diálogo :guilabel:`Prueba de plantillas`. Para facilitar su acceso, asígnele un atajo de teclado en :guilabel:`Preferencias > Avanzado > Atajos > Prueba de plantillas`. Si le asigna un atajo de teclado podrá alternar rápidamente entre la prueba de plantillas y la modificación del código de programa de la plantilla.

en: Providing additional information to templates
es: Pasar información adicional a las plantillas

en: A developer can choose to pass additional information to the template processor, such as application-specific book metadata or information about what the processor is being asked to do. A template can access this information and use it during the evaluation.
es: Un desarrollador puede decidir pasar información adicional al procesador de plantillas, como metadatos del libro específicos para una aplicación o información sobre lo que se quiere que haga el procesador. Una plantilla puede acceder a esta información y usarla durante la evaluación.

en: **Developer: how to pass additional information**
es: **Desarrollador: cómo pasar información adicional**

en: The additional information is a Python dictionary containing pairs ``variable_name: variable_value`` where the values must be strings. The template can access the dictionary, creating template local variables named ``variable_name`` containing the value ``variable_value``. The user cannot change the name so it is best to use names that won't collide with other template local variables, for example by prefixing the name with an underscore.
es: La información adicional es un diccionario Python que contiene pares ``nombre_de_variable: valor de variable`` donde los valores deberían ser textos. La plantilla puede acceder al diccionario, creando variables locales con nombre ``nombre_de_variable`` y valor ``valor de variable``. El usuario no puede cambiar el nombre, así que lo mejor es usar nombres que no entren en conflicto con otras variables locales, por ejemplo añadiendo un guión bajo al principio del nombre.

en: This dictionary is passed to the template processor (the ``formatter``) using the named parameter ``global_vars=your_dict``. The full method signature is::
es: El diccionario se pasa al procesador de plantillas (el ``formatter``) usando el argumento ``global_vars=diccionario``. La forma completa del método es::

en: **Template writer: how to access the additional information**
es: **Creador de plantillas: cómo acceder a la información adicional**

en: You access the additional information (the ``globals`` dictionary) in a template using the template function::
es: Puede acceder a la información adicional (el diccionario ``globals``) en una plantilla usando la función de plantilla::

en: where ``id`` is any legal variable name. This function checks whether the additional information provided by the developer contains the name. If it does then the function assigns the provided value to a template local variable with that name. If the name is not in the additional information and if an ``expression`` is provided, the ``expression`` is evaluated and the result is assigned to the local variable. If neither a value nor an expression is provided, the function assigns the empty string (``''``) to the local variable.
es: donde ``id`` es cualquier nombre de variable permitido. Esta función comprueba si la información adicional prevista por el desarrollador contiene el nombre. Si es así, la función asigna el valor a una variable local con ese nombre. Si el nombre no está presente en la información adicional y se suministra una ``expression``, se evalua dicha ``expression`` y el resultado se asigna a la variable local. Si no existe ni un valor ni una expresión, la función asigna el texto vacío (``''``) a la variable local.

en: A template can set a value in the ``globals`` dictionary using the template function::
es: Una plantilla puede establecer un valor en el diccionario ``globals`` usando la función de plantilla::

en: This function sets the ``globals`` dictionary key:value pair ``id:value`` where ``value`` is the value of the template local variable ``id``. If that local variable doesn't exist then ``value`` is set to the result of evaluating ``expression``.
es: Esta función asigna la pareja ``id:valor`` del diccionario ``globals``, donde ``valor`` es el valor de la variable local de la plantilla ``id``. Si la variable no existe, ``valor`` se toma como el resultado de evaluar ``expresión``.

en: Notes on the difference between modes
es: Notas sobre las diferencias entre modos

en: The three program modes, :ref:`Single Function Mode <single_mode>` (SFM), :ref:`Template Program Mode <template_mode>` (`TPM`), and :ref:`General Program Mode <general_mode>` (`GPM`), work differently. SFM is intended to be 'simple' so it hides a lot of programming language bits.
es: Los tres modos de programación, el :ref:`modo de función única <single_mode>` (`MFU`), el :ref:`modo de programación de plantillas <template_mode>` (`MPP`) y el :ref:`modo de programación general <general_mode>` (`MPG`) funcionan de distinta manera. MFU pretende ser «sencillo» y oculta muchos elementos del lenguaje de programación.

en: Differences:
es: Diferencias:

en: In SFM the value of the column is always passed as an 'invisible' first argument to a function included in the template.
es: En el MFU el valor de la columna se pasa siempre como un primer argumento «invisible» a la función que se incluye en la plantilla.

en: SFM doesn't support the difference between variables and strings; all values are strings.
es: El MFU no hace distinciones entre variables y textos; todos los valores son textos.

en: The following SFM template returns either the series name or the string "no series"::
es: La siguiente plantilla MFU devuelve el nombre de la serie o el texto ``'no series'``::

en: The equivalent template in `TPM` is ::
es: La plantilla equivalente en `MPP` es::

en: The equivalent template in `GPM` is::
es: La plantilla equivalente en `MPG` es::

en: The first argument to ``ifempty`` is the value of the field ``series``. The second argument is the string ``no series``. In SFM the first argument, the value of the field, is automatically passed (the invisible argument).
es: El primer argumento de ``ifempty`` es el valor del campo ``series``. El segundo argumento es el texto ``no series``. En MFU el primer argumento, el valor, se pasa automáticamente (es el argumento invisible).

en: Several template functions, for example ``booksize()`` and ``current_library_name()``, take no arguments. Because of the 'invisible argument' you cannot use these functions in SFM.
es: Varias funciones de plantilla, como ``booksize()`` y ``current_library_name()``, no admiten argumentos. Debido al «argumento invisible», no puede usar estas funciones en MFU.

en: Nested functions, where a function calls another function to compute an argument, cannot be used in SFM. For example this template, intended to return the first 5 characters of the series value uppercased, won't work in SFM::
es: Las funciones anidadas, en las que una función invoca a otra función para evaluar un argumento, no pueden usarse en MFU. Por ejemplo, esta plantilla, que pretende devolver los 5 primeros caracteres del valor de la serie convertidos en mayúsculas, no funcionará en MFU::

en: `TPM` and `GPM` support nested functions. The above template in `TPM` would be::
es: `MPP` y `MPG` permiten usar funciones anidadas. La plantilla anterior en `MPP` sería::

en: In `GPM` it would be::
es: En `MPG` sería::

en: As noted in the above :ref:`Template Program Mode <template_mode>` section, using ``{`` and ``}`` characters in `TPM` string literals can lead to errors or unexpected results because they confuse the template processor. It tries to treat them as template boundaries, not characters. In some but not all cases you can replace a ``{`` with ``[[`` and a ``}`` with `]]`. Generally, if your program contains ``{`` and ``}`` characters then you should use `General Program Mode`.
es: Como se mencionó ateriormente en la sección :ref:`modo de programación de plantillas`, en el `MPP`, usar los caracteres ``{`` y ``}`` en textos literales puede conducir a errores o resultados inesperados porque confunden al procesador de plantillas. Éste intenta interpretarlos como límites de plantilla y no como caracteres. En algunos casos, pero no todos, puede sustituir un ``{`` por ``[[`` y un ``}`` por ``]]``. En general, si un program contiene caracteres ``{`` y ``}``, debería usar el `modo de programación general`.

en: User-defined Python template functions
es: Funciones de plantilla Python definidas por el usuario

en: You can add your own Python functions to the template processor. Such functions can be used in any of the three template programming modes. The functions are added by going to :guilabel:`Preferences -> Advanced -> Template functions`. Instructions are shown in that dialog. Note that you can use `Python Templates` for a similar purpose. As calling user-defined functions is faster than calling a Python template, user-defined functions might be more efficient depending on the complexity of what the function or template does.
es: Puede añadir funciones propias al procesador de plantillas. Dichas funciones pueden usarse en cualquiera de los tres modos de programación de plantillas. Las funciones se añaden en :guilabel:`Preferencias > Avanzado > Funciones de plantilla`. Las instrucciones se muestran en el correspondiente cuadro de diálogo. Tenga en cuenta que puede usar `plantillas de Python` para lo mismo. Dado que es más rápido ejecutar funciones definidas por el usuario que una plantilla de Python, las funciones definidas por el usuario pueden ser más eficientes, dependiendo de la complejidad de lo que haga la función o plantilla.

en: Special notes for using templates in different contexts
es: Notas especiales para el uso de plantillas en diferentes contextos

en: In the GUI (:guilabel:`Columns made from other columns` and :guilabel:`Template searches`):
es: En la interfaz gráfica (:guilabel:`Columnas generadas a partir de otras columnas` y :guilabel:`Búsquedas por plantillas`):

en: GPM templates work as before.
es: Las plantillas MPG funcionan como antes.

en: Python templates have full access to the calibre database.
es: Las plantillas de Python tienen acceso completo a la base de datos de calibre.

en: In icon rules:
es: En las reglas de icono:

en: icon rule templates have no book data so field-based functions such as :ref:`ff_format_date_field`, :ref:`ff_list_count_field`, and :ref:`ff_check_yes_no` won't work.
es: Las plantillas de reglas de icono no tienen datos de libros, por lo que las funciones basadas en campos como :ref:`ff_format_date_field`, :ref:`ff_list_count_field` y :ref:`ff_check_yes_no` no funcionarán.

en: In the Content server:
es: En el servidor de contenidos:

en: Templates have access to the new API but not the old API (LibraryDatabase).
es: Las plantillas tienen acceso a la nueva API pero no a la API antigua (LibraryDatabase).

en: Because of the above, the following formatter functions are not guaranteed to work in GPM templates (composite columns, icon rules, etc) and should be avoided if you use the content server:
es: Debido a lo anterior, no se garantiza que las siguientes funciones de formato funcionen en plantillas MPG (columnas compuestas, reglas de icono, etc.) y se deben evitar si utiliza el servidor de contenidos:

en: Special notes for save/send templates
es: Notas especiales para plantillas de guardado o envío

en: Special processing is applied when a template is used in a :guilabel:`Save to disk` or :guilabel:`Send to device` template. The values of the fields are cleaned, replacing characters that are special to file systems with underscores, including slashes. This means that field text cannot be used to create folders. However, slashes are not changed in prefix or suffix strings, so slashes in these strings will cause folders to be created. Because of this, you can create variable-depth folder structure.
es: Cuando una plantilla se usa como plantilla para :guilabel:`Guardar en el disco` o :guilabel:`Enviar al dispositivo`, ocurre un procesado especial. Los valores de los campos se sanean, eliminando caracteres especiales para los sistemas operativos por guiones bajos, incluyendo barras. Esto significa que el texto de los campos no puede usarse para crear carpetas. Sin embargo, las barras no se modifican en los textos de prefijo o sufijo, por lo que las barras en estos textos harán que se creen carpetas. Gracias a esto, es posible crear estructuras de carpetas de profundidad variable.

en: For example, assume we want the folder structure `series/series_index - title`, with the caveat that if series does not exist, then the title should be in the top folder. The template to do this is::
es: Por ejemplo, supongamos que quiere una estructura de carpetas `serie/índice de serie - título`, con la salvedad de que si la serie no existe el título debe estar en la carpeta superior. La plantilla para conseguir esto es::

en: The slash and the hyphen appear only if series is not empty.
es: La barra y el guión sólo aparecen si la serie no está vacía.

en: The lookup function lets us do even fancier processing. For example, assume that if a book has a series, then we want the folder structure `series/series index - title.fmt`. If the book does not have a series then we want the folder structure `genre/author_sort/title.fmt`. If the book has no genre then we want to use 'Unknown'. We want two completely different paths, depending on the value of series.
es: La función ``lookup()`` nos permite realizar un procesado aún más complejo. Por ejemplo, supongamos que si un libro tiene una serie, entonces queremos una estructura de carpetas `serie/índice de serie - título`. Si el libro no tiene una serie, entonces queremos la estructura `género/orden de autor/título`. Si el libro no tiene género, queremos que use «Desconocido». Queremos seguir dos caminos completamente distintos según el valor de la serie.

en: To accomplish this, we:
es: Para lograr esto:

en: Create a composite field (give it lookup name #aa) containing ``{series}/{series_index} - {title}``. If the series is not empty, then this template will produce `series/series_index - title`.
es: Creamos un campo compuesto (démosle el nombre de consulta #aa) que contiene ``{series}/{series_index} - {title}``. Si la serie no está vacía, esta plantilla produce `serie/número_de_serie - título`.

en: Create a composite field (give it lookup name #bb) containing ``{#genre:ifempty(Unknown)}/{author_sort}/{title}``. This template produces `genre/author_sort/title`, where an empty genre is replaced with `Unknown`.
es: Creamos un campo compuesto (démosle el nombre de consulta #bb) que contenga ``{#genre:ifempty(Desconocido)}/{author_sort}/{title}``. Esta plantilla produce `género/orden de autor/título`, donde un género vacío se sustituye por `Desconocido`.

en: Set the save template to ``{series:lookup(.,#aa,#bb)}``. This template chooses composite field ``#aa`` if series is not empty and composite field ``#bb`` if series is empty. We therefore have two completely different save paths, depending on whether or not `series` is empty.
es: Establecemos la plantilla de guardado en ``{series:lookup(.,#aa,#bb)}``. Esta plantilla elige el campo compuesto ``#aa`` si la serie no está vacía y el campo compuesto ``#bb`` si la serie está vacía. Obtenemos por lo tanto dos rutas de guardado completamente diferentes según el campo `series` esté o no vacío.

en: Tips
es: Consejos

en: Use the Template Tester to test templates. Add the tester to the context menu for books in the library and/or give it a keyboard shortcut.
es: Use la prueba de plantillas para probar plantillas. Añada esta función al menú contextual para libros en lea biblioteca o asígnele un atajo de teclado.

en: Templates can use other templates by referencing composite columns built with the desired template. Alternatively, you can use Stored Templates.
es: Las plantillas pueden usar otras plantillas haciendo referencia a columnas compuestas construidas con la plantilla deseada. También puede usar plantillas guardadas.

en: In a plugboard, you can set a field to empty (or whatever is equivalent to empty) by using the special template ``{}``. This template will always evaluate to an empty string.
es: En un panel de conexiones, puede establecer un campo como vacío (o lo que sea equivalente a vacío) utilizando la plantilla especial ``{}``. Esta plantilla siempre producirá un texto vacío.

en: The technique described above to show numbers even if they have a zero value works with the standard field series_index.
es: La técnica descrita anteriormente para mostrar los números incluso si son cero funciona con el campo estándar ``series_index``.

en: Template function reference
es: Referencia de las funciones de plantilla
