calibre - en to sv translation catalogue (21 entries)

en: XPath tutorial
sv: XPath-introduktion

en: In this tutorial, you will be given a gentle introduction to `XPath <https://en.wikipedia.org/wiki/XPath>`_, a query language that can be used to select arbitrary parts of `HTML <https://en.wikipedia.org/wiki/HTML>`_ documents in calibre. XPath is a widely used standard, and googling it will yield a ton of information. This tutorial, however, focuses on using XPath for e-book related tasks like finding chapter headings in an unstructured HTML document.
sv: I den här handledningen får du en lättillgänglig introduktion till `XPath <https://en.wikipedia.org/wiki/XPath>`_, ett frågespråk som kan användas för att välja valfria delar av `HTML <https://en.wikipedia.org/wiki/HTML>`_-dokument i calibre. XPath är en etablerad standard och det finns mycket information om språket på internet. Den här handledningen fokuserar på hur XPath används för e-boksrelaterade uppgifter, till exempel för att hitta kapitelrubriker i ett ostrukturerat HTML-dokument.

en: Contents
sv: Innehåll

en: Selecting by tag name
sv: Välja efter taggnamn

en: The simplest form of selection is to select tags by name. For example, suppose you want to select all the ``<h2>`` tags in a document. The XPath query for this is simply::
sv: Det enklaste är att välja taggar efter namn. Anta till exempel att du vill välja alla ``<h2>``-taggar i ett dokument. XPath-uttrycket är då helt enkelt::

en: The prefix `//` means *search at any level of the document*. Now suppose you want to search for ``<span>`` tags that are inside ``<a>`` tags. That can be achieved with::
sv: Prefixet `//` betyder *sök på valfri nivå i dokumentet*. Anta nu att du vill söka efter ``<span>``-taggar som finns inuti ``<a>``-taggar. Det kan göras med::

en: If you want to search for tags at a particular level in the document, change the prefix::
sv: Om du vill söka efter taggar på en viss nivå i dokumentet ändrar du prefixet::

en: This will match only ``<p>A very short e-book to demonstrate the use of XPath.</p>`` in the :ref:`sample_ebook` but not any of the other ``<p>`` tags. The ``h:`` prefix in the above examples is needed to match XHTML tags. This is because internally, calibre represents all content as XHTML. In XHTML tags have a *namespace*, and ``h:`` is the namespace prefix for HTML tags.
sv: Detta matchar endast ``<p>A very short e-book to demonstrate the use of XPath.</p>`` i :ref:`sample_ebook`, inte någon av de andra ``<p>``-taggarna. Prefixet ``h:`` i exemplen ovan krävs för att matcha XHTML-taggar. Det beror på att calibre internt representerar allt innehåll som XHTML. I XHTML tillhör taggar ett *namnområde*, och ``h:`` är namnrymdsprefixet för HTML-taggar.

en: Now suppose you want to select both ``<h1>`` and ``<h2>`` tags. To do that, we need an XPath construct called *predicate*. A :dfn:`predicate` is simply a test that is used to select tags. Tests can be arbitrarily powerful and as this tutorial progresses, you will see more powerful examples. A predicate is created by enclosing the test expression in square brackets::
sv: Anta nu att du vill välja både ``<h1>``- och ``<h2>``-taggar. Då behöver vi en XPath-konstruktion som kallas *predikat*. Ett :dfn:`predikat` är ett villkor som används för att välja taggar. Villkoren kan vara godtyckligt avancerade, och längre fram i handledningen visas kraftfullare exempel. Ett predikat skapas genom att omge villkorsuttrycket med hakparenteser::

en: There are several new features in this XPath expression. The first is the use of the wildcard ``*``. It means *match any tag*. Now look at the test expression ``name()='h1' or name()='h2'``. :term:`name()` is an example of a *built-in function*. It simply evaluates to the name of the tag. So by using it, we can select tags whose names are either `h1` or `h2`. Note that the :term:`name()` function ignores namespaces so that there is no need for the ``h:`` prefix. XPath has several useful built-in functions. A few more will be introduced in this tutorial.
sv: Det finns flera nya delar i XPath-uttrycket. Den första är jokertecknet ``*``, som betyder *matcha valfri tagg*. Titta sedan på villkorsuttrycket ``name()='h1' or name()='h2'``. :term:`name()` är en *inbyggd funktion* som returnerar taggens namn. Med den kan vi välja taggar vars namn är antingen `h1` eller `h2`. Funktionen :term:`name()` ignorerar namnrymder, så prefixet ``h:`` behövs inte. XPath har flera användbara inbyggda funktioner. Några fler presenteras i den här handledningen.

en: Selecting by attributes
sv: Välja efter attribut

en: To select tags based on their attributes, the use of predicates is required::
sv: För att välja taggar utifrån deras attribut krävs predikat::

en: Here, the ``@`` operator refers to the attributes of the tag. You can use some of the `XPath built-in functions`_ to perform more sophisticated matching on attribute values.
sv: Här hänvisar operatorn ``@`` till taggens attribut. Du kan använda några av `XPaths inbyggda funktioner`_ för att göra mer avancerade matchningar av attributvärden.

en: Selecting by tag content
sv: Välja efter tagginnehåll

en: Using XPath, you can even select tags based on the text they contain. The best way to do this is to use the power of *regular expressions* via the built-in function :term:`re:test()`::
sv: Med XPath kan du även välja taggar utifrån den text de innehåller. Det bästa sättet är att använda *reguljära uttryck* via den inbyggda funktionen :term:`re:test()`::

en: Here the ``.`` operator refers to the contents of the tag, just as the ``@`` operator referred to its attributes.
sv: Här hänvisar ``.``-operatören till innehållet i taggen, precis som ``@``-operatören avser dess attribut.

en: Sample e-book
sv: Exempel-e-bok

en: XPath built-in functions
sv: XPaths inbyggda funktioner

en: The name of the current tag.
sv: Namnet på den aktuella taggen.

en: ``contains(s1, s2)`` returns `true` if s1 contains s2.
sv: ``contains(s1, s2)`` returnerar `true` om s1 innehåller s2.

en: ``re:test(src, pattern, flags)`` returns `true` if the string `src` matches the regular expression `pattern`. A particularly useful flag is ``i``, it makes matching case insensitive. A good primer on the syntax for regular expressions can be found at `regexp syntax <https://docs.python.org/library/re.html>`_
sv: ``re:test(src, pattern, flags)`` returnerar `true` om strängen `src` matchar det reguljära uttrycket `pattern`. En särskilt användbar flagga är ``i``, som gör matchningen skiftlägesokänslig. En bra introduktion till syntaxen finns i `Python-dokumentationen <https://docs.python.org/library/re.html>`_.
