calibre - en to sv translation catalogue (21 entries)

en: XPath tutorial
sv: XPath-handledning

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 kommer du att få en kort introduktion till `XPath <https://sv.wikipedia.org/wiki/XPath>`_, ett frågespråk som kan användas för att välja godtyckliga delar av `HTML <https://sv.wikipedia.org/wiki/HTML>`_-dokument i calibre. XPath är en allmänt använd standard, och att googla det kommer att ge massor av information. Den här handledningen fokuserar däremot på att använda XPath för e-bokrelaterade uppgifter som 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: Den enklaste formen av val är att välja taggar efter namn. Anta till exempel att du vill välja alla ``<h2>``-taggar i ett dokument. XPath-förfrågan till detta är 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ökning på alla nivåer i dokumentet*. Anta nu att du vill söka efter ``<span>``-taggar som finns inuti ``<a>``-taggar. Det kan uppnås 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, ändra 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: Det här kommer endast att matcha ``<p>En mycket kort e-bok för att demonstrera användningen av XPath.</p>`` i :ref:`sample_ebook` men inte någon av de andra ``<p>``-taggarna. Prefixet ``h:`` i exemplen ovan behövs för att matcha XHTML-taggar. Det här beror på att calibre internt representerar allt innehåll som XHTML. I XHTML har taggar ett *namespace* och ``h:`` är namespace-prefixet 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. För att göra det behöver vi en XPath-konstruktion som heter *predicate*. :dfn:`predicate` är helt enkelt ett test som används för att välja taggar. Tester kan vara godtyckligt kraftfulla och allt eftersom den här handledningen fortskrider kommer du att se fler kraftfulla exempel. Ett predikat skapas genom att omsluta testuttrycket inom 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 funktioner i detta XPath-uttryck. Den första är användningen av tecknet ``*``. Det betyder *matcha alla taggar*. Titta nu på testuttrycket ``name()='h1' or name()='h2'``. :term:`name()` är ett exempel på en *inbyggd funktion*. Den utvärderar helt enkelt namnet på taggen. Så genom att använda det kan vi välja taggar vars namn är antingen `h1` eller `h2`. Observera att funktionen :term:`name()` ignorerar namespaces så det inte finns något behov av prefixet ``h:``. XPath har flera användbara inbyggda funktioner. Några fler kommer att introduceras i den här guiden.

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 baserat på deras attribut, användning av predikat krävs::

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 operatören ``@`` till attributen för taggen. Du kan använda en del av de `XPath inbyggda funktioner`_ att utföra mer avancerad matchning på 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 hjälp av XPath kan du även välja taggar som baseras på text de innehåller. Det bästa sättet att göra detta är att använda kraften i *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: XPath 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 med det reguljära uttrycks `mönster`. En särskilt användbar flaggan är ``i``, det gör matchning skiftlägesokänslig. En bra grund på syntaxen för reguljära uttryck finns på `regexp syntax <https://docs.python.org/library/re.html>`_
