calibre - en to sv translation catalogue (49 entries)

en: All about using regular expressions in calibre
sv: Allt om att använda reguljära uttryck i calibre

en: Regular expressions are features used in many places in calibre to perform sophisticated manipulation of e-book content and metadata. This tutorial is a gentle introduction to getting you started with using regular expressions in calibre.
sv: Reguljära uttryck används på många ställen i calibre för avancerad bearbetning av e-böckers innehåll och metadata. Den här handledningen ger en lättillgänglig introduktion som hjälper dig att komma igång med reguljära uttryck i calibre.

en: Contents
sv: Innehåll

en: First, a word of warning and a word of courage
sv: Först några varnande och uppmuntrande ord

en: This is, inevitably, going to be somewhat technical- after all, regular expressions are a technical tool for doing technical stuff. I'm going to have to use some jargon and concepts that may seem complicated or convoluted. I'm going to try to explain those concepts as clearly as I can, but really can't do without using them at all. That being said, don't be discouraged by any jargon, as I've tried to explain everything new. And while regular expressions themselves may seem like an arcane, black magic (or, to be more prosaic, a random string of mumbo-jumbo letters and signs), I promise that they are not all that complicated. Even those who understand regular expressions really well have trouble reading the more complex ones, but writing them isn't as difficult- you construct the expression step by step. So, take a step and follow me into the rabbit hole.
sv: Detta blir ofrånkomligen ganska tekniskt – reguljära uttryck är trots allt ett tekniskt verktyg för tekniska uppgifter. Jag behöver använda en del facktermer och begrepp som kan verka komplicerade eller invecklade. Jag ska försöka förklara dem så tydligt som möjligt, men kan inte helt undvika dem. Låt dig därför inte avskräckas av facktermerna; jag har försökt förklara allt nytt. Reguljära uttryck kan verka som svårbegriplig svartkonst – eller, mer prosaiskt, som en slumpmässig blandning av bokstäver och tecken – men jag lovar att de inte är så komplicerade. Även den som behärskar reguljära uttryck väl kan ha svårt att läsa de mer avancerade, men det är inte lika svårt att skriva dem: du bygger uttrycket steg för steg. Ta därför första steget och följ med ner i kaninhålet.

en: Where in calibre can you use regular expressions?
sv: Var i calibre kan man använda reguljära uttryck?

en: There are a few places calibre uses regular expressions. There's the :guilabel:`Search & replace` in conversion options, metadata detection from filenames in the import settings and Search & replace when editing the metadata of books in bulk. The calibre book editor can also use regular expressions in its :guilabel:`Search and replace` feature. Finally, you can use regular expressions when searching the calibre book list and when searching inside the calibre E-book viewer.
sv: calibre använder reguljära uttryck på flera ställen: i :guilabel:`Sök och ersätt` bland konverteringsalternativen, vid identifiering av metadata från filnamn i importinställningarna och i Sök och ersätt vid massredigering av metadata. Bokredigeraren använder också reguljära uttryck i funktionen :guilabel:`Sök och ersätt`. Slutligen kan du använda dem när du söker i calibres boklista och i e-bokvisaren.

en: What on earth *is* a regular expression?
sv: Vad i hela världen *är* ett reguljärt uttryck?

en: A regular expression is a way to describe sets of strings. A single regular expression can *match* a number of different strings. This is what makes regular expression so powerful -- they are a concise way of describing a potentially large number of variations.
sv: Ett reguljärt uttryck är ett sätt att beskriva mängder av strängar. Ett enda reguljärt uttryck kan *matcha* flera olika strängar. Det är detta som gör reguljära uttryck så kraftfulla: de beskriver ett potentiellt stort antal variationer på ett kortfattat sätt.

en: I'm using string here in the sense it is used in programming languages: a string of one or more characters, characters including actual characters, numbers, punctuation and so-called whitespace (linebreaks, tabulators etc.). Please note that generally, uppercase and lowercase characters are not considered the same, thus "a" being a different character from "A" and so forth. In calibre, regular expressions are case insensitive in the Search bar, but not in the conversion options. There's a way to make every regular expression case insensitive, but we'll discuss that later. It gets complicated because regular expressions allow for variations in the strings it matches, so one expression can match multiple strings, which is why people bother using them at all. More on that in a bit.
sv: Jag använder sträng här i den mening den används i programspråk: en sträng av ett eller flera tecken, tecken inklusive faktiska tecken, siffror, skiljetecken och s.k. whitespace (radbrytningar, tabulatorer etc.). Observera att i allmänhet anses inte stora och små bokstäver vara samma, alltså "a" som ett annat tecken från "A" och så vidare. I calibre, är reguljära uttryck skiftlägesokänslig i sökfältet, men inte i konverteringsalternativet. Det finns ett sätt att göra alla reguljära uttryck skiftlägesokänsliga, men vi kommer att diskutera det senare. Det blir komplicerat eftersom reguljära uttryck tillåter variationer i strängar som matchar, så ett uttryck kan matcha flera strängar, vilket är varför folk bryr sig att använda dem. Mer om det om ett tag.

en: Care to explain?
sv: Har du lust att förklara?

en: Well, that's why we're here. First, this is the most important concept in regular expressions: *A string by itself is a regular expression that matches itself*. That is to say, if I wanted to match the string ``"Hello, World!"`` using a regular expression, the regular expression to use would be ``Hello, World!``. And yes, it really is that simple. You'll notice, though, that this *only* matches the exact string ``"Hello, World!"``, not e.g. ``"Hello, wOrld!"`` or ``"hello, world!"`` or any other such variation.
sv: Tja, det är därför vi är här. För det första är detta det viktigaste konceptet i reguljära uttryck: *En sträng i sig är ett reguljärt uttryck som matchar sig själv*. Det vill säga, om jag ville matcha strängen ``"Hej, Värld!"`` genom att använda ett reguljärt uttryck, skulle det reguljära uttrycket för att använda vara ``Hej, Värld!``. Och ja, det är verkligen så enkelt. Du kommer att märka dock att detta *endast* matchar den exakta strängen ``"Hej, Värld!"``, inte t.ex. ``"Hej vÄrlden!"`` eller ``"hej, värld!"`` eller någon annan sådan variation.

en: That doesn't sound too bad. What's next?
sv: Det låter inte så illa. Vad kommer härnäst?

en: Next is the beginning of the really good stuff. Remember where I said that regular expressions can match multiple strings? This is where it gets a little more complicated. Say, as a somewhat more practical exercise, the e-book you wanted to convert had a nasty footer counting the pages, like "Page 5 of 423". Obviously the page number would rise from 1 to 423, thus you'd have to match 423 different strings, right? Wrong, actually: regular expressions allow you to define sets of characters that are matched: To define a set, you put all the characters you want to be in the set into square brackets. So, for example, the set ``[abc]`` would match either the character "a", "b" or "c". *Sets will always only match one of the characters in the set*. They "understand" character ranges, that is, if you wanted to match all the lower case characters, you'd use the set ``[a-z]`` for lower- and uppercase characters you'd use ``[a-zA-Z]`` and so on. Got the idea? So, obviously, using the expression ``Page [0-9] of 423`` you'd be able to match the first 9 pages, thus reducing the expressions needed to three: The second expression ``Page [0-9][0-9] of 423`` would match all two-digit page numbers, and I'm sure you can guess what the third expression would look like. Yes, go ahead. Write it down.
sv: Nästa är början på riktigt bra grejer. Kom ihåg var jag sa att reguljära uttryck kan matcha flera strängar? Det är här det blir lite mer komplicerat. Säg, som en något mer praktisk övning, e-boken du ville konvertera hade en otäck sidfot som räknar sidor, "Sida 5 av 423". Uppenbarligen skulle sidnumret stiga från 1 till 423, så du skulle behöva matcha 423 olika strängar, eller hur? Fel, faktiskt: reguljära uttryck tillåter dig definiera uppsättningar av tecken som matchar: För att definiera en uppsättning, lägger du alla de tecken du vill att ska vara i uppsättningen inom hakparenteser. Så, till exempel uppsättningen ``[abc]`` skulle matcha antingen tecknet "a", "b" eller "c". *Uppsättningarna kommer alltid bara matcha en av karaktärerna i uppsättningen*. De "förstår" teckenformattering, det vill säga om du ville matcha mot alla små bokstäver, skulle du använda uppsättningen ``[a-z]`` för gemener och för versaler skulle du använda ``[a-zA-Z]`` osv. Förstår du principen? Så, självklart, med hjälp av uttrycket ``Sida [0-9] av 423`` skulle du kunna matcha de första nio sidorna, vilket minskar uttrycken som behövs för tre: Det andra uttrycket ``Sida [0-9][0-9] av 423`` skulle matcha alla tvåsiffriga sidnummer, och jag är säker på att du kan gissa hur det tredje uttryck skulle se ut. Ja, gå vidare. Skriv ner det.

en: Hey, neat! This is starting to make sense!
sv: Snyggt! Nu börjar det klarna!

en: I was hoping you'd say that. But brace yourself, now it gets even better! We just saw that using sets, we could match one of several characters at once. But you can even repeat a character or set, reducing the number of expressions needed to handle the above page number example to one. Yes, ONE! Excited? You should be! It works like this: Some so-called special characters, "+", "?" and "*", *repeat the single element preceding them*. (Element means either a single character, a character set, an escape sequence or a group (we'll learn about those last two later)- in short, any single entity in a regular expression). These characters are called wildcards or quantifiers. To be more precise, "?" matches *0 or 1* of the preceding element, "*" matches *0 or more* of the preceding element and "+" matches *1 or more* of the preceding element. A few examples: The expression ``a?`` would match either "" (which is the empty string, not strictly useful in this case) or "a", the expression ``a*`` would match "", "a", "aa" or any number of a's in a row, and, finally, the expression ``a+`` would match "a", "aa" or any number of a's in a row (Note: it wouldn't match the empty string!). Same deal for sets: The expression ``[0-9]+`` would match *every integer number there is*! I know what you're thinking, and you're right: If you use that in the above case of matching page numbers, wouldn't that be the single one expression to match all the page numbers? Yes, the expression ``Page [0-9]+ of 423`` would match every page number in that book!
sv: Jag hoppades att du skulle säga det. Men håll i dig, för nu blir det ännu bättre! Vi såg nyss att en teckenuppsättning kan matcha ett av flera tecken samtidigt. Du kan dessutom upprepa ett tecken eller en teckenuppsättning och därmed minska antalet uttryck som behövs för sidnummerexemplet ovan till ett enda. Ja, ETT! Visst är det spännande? Så här fungerar det: Specialtecknen "+", "?" och "*" *upprepar det enskilda element som står närmast före dem*. Ett element kan vara ett enskilt tecken, en teckenuppsättning, en escape-sekvens eller en grupp (vi återkommer till de två sistnämnda senare) – kort sagt en enskild enhet i ett reguljärt uttryck. Tecknen kallas jokertecken eller kvantifierare. Mer exakt matchar "?" *0 eller 1* förekomst av det föregående elementet, "*" matchar *0 eller flera* och "+" matchar *1 eller flera*. Några exempel: Uttrycket ``a?`` matchar antingen "" (den tomma strängen, som inte är särskilt användbar i just detta fall) eller "a". Uttrycket ``a*`` matchar "", "a", "aa" eller valfritt antal a i följd. Slutligen matchar ``a+`` "a", "aa" eller valfritt antal a i följd (observera att det inte matchar den tomma strängen). Detsamma gäller teckenuppsättningar: Uttrycket ``[0-9]+`` matchar *vilket heltal som helst*! Jag vet vad du tänker, och du har rätt: Om du använder det i sidnummerexemplet ovan, blir inte detta då det enda uttryck som behövs för att matcha alla sidnummer? Jo, uttrycket ``Page [0-9]+ of 423`` matchar varje sidnummer i boken!

en: A note on these quantifiers: They generally try to match as much text as possible, so be careful when using them. This is called "greedy behaviour"- I'm sure you get why. It gets problematic when you, say, try to match a tag. Consider, for example, the string ``"<p class="calibre2">Title here</p>"`` and let's say you'd want to match the opening tag (the part between the first pair of angle brackets, a little more on tags later). You'd think that the expression ``<p.*>`` would match that tag, but actually, it matches the whole string! (The character "." is another special character. It matches anything *except* linebreaks, so, basically, the expression ``.*`` would match any single line you can think of). Instead, try using ``<p.*?>`` which makes the quantifier ``"*"`` non-greedy. That expression would only match the first opening tag, as intended. There's actually another way to accomplish this: The expression ``<p[^>]*>`` will match that same opening tag- you'll see why after the next section. Just note that there quite frequently is more than one way to write a regular expression.
sv: En kommentar om dessa kvantifierare: De försöker i allmänhet att matcha så mycket text som möjligt, så var försiktig när du använder dem. Detta kallas "girigt beteende" - Jag är säker på att du förstår varför. Det blir problematiskt när man, säg, försöker matcha en tagg. Tänk dig, till exempel strängen ``"<p class="calibre2">Titel här</p>"`` och låt oss säga att du skulle vilja matcha öppningstaggen (delen mellan det första paret vinkelfästen, lite mer om taggar senare). Man skulle kunna tro att uttrycket ``<p.*>`` skulle matcha den taggen men faktiskt, den matchar hela strängen! (Tecknet "." är ett annat specialtecken. Det matchar allt utom radbrytningar, så uttrycket ``.*`` matchar i princip vilken enskild rad som helst. Använd i stället ``<p.*?>`` för att göra kvantifieraren ``"*"`` icke-girig. Uttrycket matchar då endast den första öppningstaggen, som avsett. Det finns faktiskt ett annat sätt att åstadkomma detta: Uttrycket ``<p[^>]*>`` matchar denna öppningstagg- du kommer se varför efter nästa avsnitt. Bara konstatera att det ganska ofta finns mer än ett sätt att skriva ett reguljärt uttryck.

en: Well, these special characters are very neat and all, but what if I wanted to match a dot or a question mark?
sv: De här specialtecknen är praktiska, men hur matchar jag en punkt eller ett frågetecken?

en: You can of course do that: Just put a backslash in front of any special character and it is interpreted as the literal character, without any special meaning. This pair of a backslash followed by a single character is called an escape sequence, and the act of putting a backslash in front of a special character is called escaping that character. An escape sequence is interpreted as a single element. There are of course escape sequences that do more than just escaping special characters, for example ``"\t"`` means a tabulator. We'll get to some of the escape sequences later. Oh, and by the way, concerning those special characters: Consider any character we discuss in this introduction as having some function to be special and thus needing to be escaped if you want the literal character.
sv: Det kan du naturligtvis göra. Sätt bara ett omvänt snedstreck framför ett specialtecken, så tolkas det som det bokstavliga tecknet utan någon särskild betydelse. Ett omvänt snedstreck följt av ett enda tecken kallas en escape-sekvens, och att sätta ett omvänt snedstreck framför ett specialtecken kallas att maskera tecknet. En escape-sekvens tolkas som ett enda element. Det finns även escape-sekvenser som gör mer än att bara maskera specialtecken; ``"\t"`` betyder till exempel en tabulator. Vi återkommer till några av escape-sekvenserna senare. Betrakta för övrigt alla tecken som beskrivs som specialtecken i den här introduktionen som tecken med en särskild funktion, vilket innebär att de måste maskeras när du vill matcha själva tecknet.

en: So, what are the most useful sets?
sv: Så, vilka är de användbaraste uppsättningarna?

en: Knew you'd ask. Some useful sets are ``[0-9]`` matching a single number, ``[a-z]`` matching a single lowercase letter, ``[A-Z]`` matching a single uppercase letter, ``[a-zA-Z]`` matching a single letter and ``[a-zA-Z0-9]`` matching a single letter or number. You can also use an escape sequence as shorthand:
sv: Jag visste att du skulle fråga. Några användbara teckenuppsättningar är ``[0-9]``, som matchar en enda siffra, ``[a-z]``, som matchar en enda gemen, ``[A-Z]``, som matchar en enda versal, ``[a-zA-Z]``, som matchar en enda bokstav, och ``[a-zA-Z0-9]``, som matchar en enda bokstav eller siffra. Du kan också använda en escape-sekvens som kortform:

en: is equivalent to ``[0-9]``
sv: motsvarar ``[0-9]``

en: is equivalent to ``[a-zA-Z0-9_]``
sv: motsvarar ``[a-zA-Z0-9_]``

en: is equivalent to any whitespace
sv: motsvarar valfritt blanktecken

en: "Whitespace" is a term for anything that won't be printed. These characters include space, tabulator, line feed, form feed, carriage return, non-breaking spaces, etc.
sv: "Whitespace" är en term för allt som inte kommer att skrivas ut. Dessa tecken inkluderar blanksteg, tabulator, radmatning, formulärmatning, vagnretur, icke-brytande blanksteg etc.

en: The upper and lower case sets may match both upper and lowercase if the setting to make searches case insensitive is enabled. Such settings are found, for instance in Preferences->Searching in calibre itself and on the Search panel in the calibre :guilabel:`E-book viewer` as well as the calibre :guilabel:`Edit book` tool.
sv: Uppsättningarna för versaler och gemener kan matcha båda skiftlägena om skiftlägesokänslig sökning är aktiverad. Sådana inställningar finns till exempel under Inställningar->Sökning i calibre, i sökpanelen i calibres :guilabel:`e-bokvisare` och i verktyget :guilabel:`Redigera bok`.

en: As a last note on sets, you can also define a set as any character *but* those in the set. You do that by including the character ``"^"`` as the *very first character in the set*. Thus, ``[^a]`` would match any character excluding "a". That's called complementing the set. Those escape sequence shorthands we saw earlier can also be complemented: ``"\D"`` means any non-number character, thus being equivalent to ``[^0-9]``. The other shorthands can be complemented by, you guessed it, using the respective uppercase letter instead of the lowercase one. So, going back to the example ``<p[^>]*>`` from the previous section, now you can see that the character set it's using tries to match any character except for a closing angle bracket.
sv: Som en sista anmärkning om teckenuppsättningar kan du definiera en uppsättning som matchar alla tecken *utom* dem som ingår i uppsättningen. Det gör du genom att placera tecknet ``"^"`` som det *allra första tecknet i uppsättningen*. ``[^a]`` matchar alltså alla tecken utom "a". Detta kallas att komplementera uppsättningen. De kortformer med escape-sekvenser som vi såg tidigare kan också komplementeras: ``"\D"`` betyder ett valfritt tecken som inte är en siffra och motsvarar därför ``[^0-9]``. De andra kortformerna komplementeras genom att den gemena bokstaven byts mot motsvarande versal. I exemplet ``<p[^>]*>`` från föregående avsnitt försöker teckenuppsättningen alltså matcha alla tecken utom en avslutande vinkelparentes.

en: But if I had a few varying strings I wanted to match, things get complicated?
sv: Men om jag hade några olika strängar jag ville matcha, blir saker komplicerade?

en: Fear not, life still is good and easy. Consider this example: The book you're converting has "Title" written on every odd page and "Author" written on every even page. Looks great in print, right? But in e-books, it's annoying. You can group whole expressions in normal parentheses, and the character ``"|"`` will let you match *either* the expression to its right *or* the one to its left. Combine those and you're done. Too fast for you? Okay, first off, we group the expressions for odd and even pages, thus getting ``(Title)(Author)`` as our two needed expressions. Now we make things simpler by using the vertical bar (``"|"`` is called the vertical bar character): If you use the expression ``(Title|Author)`` you'll either get a match for "Title" (on the odd pages) or you'd match "Author" (on the even pages). Well, wasn't that easy?
sv: Frukta inte, livet är fortfarande bra och enkelt. Tänk på detta exempel: Boken du konverterar har "Titel" skrivet på varje udda sida och "Författare" skrivet på varje jämn sida. Ser bra i tryck, eller hur? Men i e-böcker är det irriterande. Du kan gruppera hela uttryck i normala parenteser och tecknet ``"|"`` låter dig matcha *antingen* uttrycket till höger *eller* det till vänster. Kombinera dem så är du klar. För snabbt för dig? Okej, först och främst grupperar vi uttryck för udda och jämna sidor och på så sätt får ``(Titel)(Författare)`` som våra två nödvändiga uttryck. Nu gör vi det enklare genom att använda det lodräta strecket (``"|"`` kallas vertikala stapeltecknet): Om du använder uttrycket ``(Titel|Författare)`` får du antingen en träff för "Titel" (på udda sidorna) eller så får du en träff för "Författare" (på jämna sidorna). Var det inte lätt?

en: You can, of course, use the vertical bar without using grouping parentheses, as well. Remember when I said that quantifiers repeat the element preceding them? Well, the vertical bar works a little differently: The expression "Title|Author" will also match either the string "Title" or the string "Author", just as the above example using grouping. *The vertical bar selects between the entire expression preceding and following it*. So, if you wanted to match the strings "Calibre" and "calibre" and wanted to select only between the upper- and lowercase "c", you'd have to use the expression ``(c|C)alibre``, where the grouping ensures that only the "c" will be selected. If you were to use ``c|Calibre``, you'd get a match on the string "c" or on the string "Calibre", which isn't what we wanted. In short: If in doubt, use grouping together with the vertical bar.
sv: Du kan naturligtvis också använda det lodräta strecket utan grupperingsparenteser. Minns du att kvantifierare upprepar elementet framför dem? Det lodräta strecket fungerar annorlunda: Uttrycket "Titel|Författare" matchar antingen strängen "Titel" eller strängen "Författare", precis som i grupperingsexemplet ovan. *Det lodräta strecket väljer mellan hela uttrycket före och hela uttrycket efter strecket*. Om du vill matcha strängarna "Calibre" och "calibre" och bara välja mellan versalt och gement "c" måste du därför använda uttrycket ``(c|C)alibre``. Grupperingen gör att endast "c" väljs. Med ``c|Calibre`` skulle uttrycket i stället matcha strängen "c" eller strängen "Calibre". Kort sagt: använd gruppering tillsammans med det lodräta strecket när du är osäker.

en: You missed...
sv: Du missade...

en: ... wait just a minute, there's one last, really neat thing you can do with groups. If you have a group that you previously matched, you can use references to that group later in the expression: Groups are numbered starting with 1, and you reference them by escaping the number of the group you want to reference, thus, the fifth group would be referenced as ``\5``. So, if you searched for ``([^ ]+) \1`` in the string "Test Test", you'd match the whole string!
sv: ... vänta lite, det finns en sista riktigt användbar sak du kan göra med grupper. Om du tidigare har matchat en grupp kan du hänvisa till den senare i uttrycket. Grupperna numreras från 1, och du hänvisar till en grupp genom att skriva ett omvänt snedstreck framför gruppnumret. Den femte gruppen anges alltså som ``\5``. Om du söker efter ``([^ ]+) \1`` i strängen "Test Test" matchas hela strängen!

en: In the beginning, you said there was a way to make a regular expression case insensitive?
sv: I början sa du att det fanns ett sätt att göra ett reguljärt uttryck skiftlägesokänsligt?

en: Yes, I did, thanks for paying attention and reminding me. You can tell calibre how you want certain things handled by using something called flags. You include flags in your expression by using the special construct ``(?flags go here)`` where, obviously, you'd replace "flags go here" with the specific flags you want. For ignoring case, the flag is ``i``, thus you include ``(?i)`` in your expression. Thus, ``(?i)test`` would match "Test", "tEst", "TEst" and any case variation you could think of.
sv: Ja, tack för påminnelsen. Med så kallade flaggor kan du ange hur calibre ska behandla uttrycket. Flaggor skrivs med konstruktionen ``(?flags go here)``, där texten ersätts med de flaggor du vill använda. Flaggan ``i`` gör matchningen skiftlägesokänslig, så du skriver ``(?i)`` i uttrycket. ``(?i)test`` matchar exempelvis "Test", "tEst", "TEst" och andra skiftlägesvarianter.

en: Another useful flag lets the dot match any character at all, *including* the newline, the flag ``s``. If you want to use multiple flags in an expression, just put them in the same statement: ``(?is)`` would ignore case and make the dot match all. It doesn't matter which flag you state first, ``(?si)`` would be equivalent to the above.
sv: En annan användbar flagga, ``s``, gör att punkten matchar alla tecken, *även* radbrytningar. Om du vill använda flera flaggor i ett uttryck placerar du dem i samma konstruktion: ``(?is)`` gör sökningen skiftlägesokänslig och låter punkten matcha alla tecken. Flaggornas ordning spelar ingen roll; ``(?si)`` motsvarar alltså uttrycket ovan.

en: I think I'm beginning to understand these regular expressions now... how do I use them in calibre?
sv: Jag tror jag börjar förstå dessa reguljära uttryck nu... hur använder jag dem i calibre?

en: Conversions
sv: Konverteringar

en: Let's begin with the conversion settings, which is really neat. In the :guilabel:`Search & replace` part, you can input a regexp (short for regular expression) that describes the string that will be replaced during the conversion. The neat part is the wizard. Click on the wizard staff and you get a preview of what calibre "sees" during the conversion process. Scroll down to the string you want to remove, select and copy it, paste it into the regexp field on top of the window. If there are variable parts, like page numbers or so, use sets and quantifiers to cover those, and while you're at it, remember to escape special characters, if there are some. Hit the button labeled :guilabel:`Test` and calibre highlights the parts it would replace were you to use the regexp. Once you're satisfied, hit OK and convert. Be careful if your conversion source has tags like this example::
sv: Vi börjar med konverteringsinställningarna. Under :guilabel:`Sök och ersätt` kan du ange ett reguljärt uttryck som beskriver den text som ska ersättas under konverteringen. Det praktiska är guiden. Klicka på trollstaven för att visa en förhandsgranskning av det calibre ser under konverteringen. Bläddra till texten du vill ta bort, markera och kopiera den och klistra sedan in den i fältet för reguljära uttryck högst upp i fönstret. Om texten innehåller varierande delar, till exempel sidnummer, använder du teckenuppsättningar och kvantifierare för att matcha dem. Kom också ihåg att föregå specialtecken med ett omvänt snedstreck. Klicka på :guilabel:`Test` så markerar calibre de delar som skulle ersättas. När du är nöjd klickar du på OK och genomför konverteringen. Var försiktig om konverteringskällan innehåller taggar som i följande exempel::

en: (shamelessly ripped out of `this thread <https://www.mobileread.com/forums/showthread.php?t=75594">`_). You'd have to remove some of the tags as well. In this example, I'd recommend beginning with the tag ``<b class="calibre2">``, now you have to end with the corresponding closing tag (opening tags are ``<tag>``, closing tags are ``</tag>``), which is simply the next ``</b>`` in this case. (Refer to a good HTML manual or ask in the forum if you are unclear on this point). The opening tag can be described using ``<b.*?>``, the closing tag using ``</b>``, thus we could remove everything between those tags using ``<b.*?>.*?</b>``. But using this expression would be a bad idea, because it removes everything enclosed by <b>- tags (which, by the way, render the enclosed text in bold print), and it's a fair bet that we'll remove portions of the book in this way. Instead, include the beginning of the enclosed string as well, making the regular expression ``<b.*?>\s*Generated\s+by\s+ABC\s+Amber\s+LIT.*?</b>`` The ``\s`` with quantifiers are included here instead of explicitly using the spaces as seen in the string to catch any variations of the string that might occur. Remember to check what calibre will remove to make sure you don't remove any portions you want to keep if you test a new expression. If you only check one occurrence, you might miss a mismatch somewhere else in the text. Also note that should you accidentally remove more or fewer tags than you actually wanted to, calibre tries to repair the damaged code after doing the removal.
sv: (skamlöst hämtat från `denna tråd <https://www.mobileread.com/forums/showthread.php?t=75594">`_). Du måste även ta bort några av taggarna. I det här exemplet rekommenderar jag att du börjar med taggen ``<b class="calibre2">``. Därefter måste uttrycket avslutas med motsvarande sluttagg (öppningstaggar skrivs ``<tag>`` och sluttaggar ``</tag>``), vilket i detta fall helt enkelt är nästa ``</b>``. (Läs en bra HTML-handbok eller fråga i forumet om detta är oklart.) Öppningstaggen kan beskrivas med ``<b.*?>`` och sluttaggen med ``</b>``. Vi skulle alltså kunna ta bort allt mellan taggarna med ``<b.*?>.*?</b>``. Det är dock en dålig idé att använda det uttrycket, eftersom det tar bort allt som omges av <b>-taggar (vilka för övrigt visar den omslutna texten med fetstil), och då riskerar vi att ta bort delar av boken. Ta därför även med början av den omslutna strängen och använd det reguljära uttrycket ``<b.*?>\s*Generated\s+by\s+ABC\s+Amber\s+LIT.*?</b>``. Här används ``\s`` tillsammans med kvantifierare i stället för de uttryckliga blanksteg som syns i strängen, så att eventuella variationer av strängen också fångas. Kontrollera alltid vad calibre tänker ta bort när du provar ett nytt uttryck, så att du inte råkar ta bort något du vill behålla. Om du bara kontrollerar en förekomst kan du missa en felaktig matchning någon annanstans i texten. Observera också att calibre försöker reparera den skadade koden efter borttagningen om du av misstag tar bort fler eller färre taggar än avsett.

en: Adding books
sv: Lägga till böcker

en: Another thing you can use regular expressions for is to extract metadata from filenames. You can find this feature in the "Adding books" part of the settings. There's a special feature here: You can use field names for metadata fields, for example ``(?P<title>)`` would indicate that calibre uses this part of the string as book title. The allowed field names are listed in the windows, together with another nice test field. An example: Say you want to import a whole bunch of files named like ``Classical Texts: The Divine Comedy by Dante Alighieri.mobi``. (Obviously, this is already in your library, since we all love classical Italian poetry) or ``Science Fiction epics: The Foundation Trilogy by Isaac Asimov.epub``. This is obviously a naming scheme that calibre won't extract any meaningful data out of - its standard expression for extracting metadata is ``(?P<title>.+) - (?P<author>[^_]+)``. A regular expression that works here would be ``[a-zA-Z]+: (?P<title>.+) by (?P<author>.+)``. Please note that, inside the group for the metadata field, you need to use expressions to describe what the field actually matches. And also note that, when using the test field calibre provides, you need to add the file extension to your testing filename, otherwise you won't get any matches at all, despite using a working expression.
sv: En annan sak du kan använda reguljära uttryck för är att extrahera metadata från filnamn. Du hittar den här funktionen i delen "Lägga till böcker" i inställningarna. Det finns en speciell funktion här: Du kan använda fältnamn för metadatafält, till exempel ``(?P<title>)`` skulle indikera att calibre använder den här delen av strängen som boktitel. De tillåtna fältnamnen listas i fönstren, tillsammans med ett annat bra testfält. Ett exempel: Säg att du vill importera en hel massa filer med namnen ``Klassiska texter: Den gudomliga komedin av Dante Alighieri.mobi``. (Detta finns uppenbarligen redan i ditt bibliotek, eftersom vi alla älskar klassisk italiensk poesi) eller ``Science Fiction-epos: Grundtrilogin av Isaac Asimov.epub``. Detta är uppenbarligen ett namngivningsschema som calibre inte kommer att extrahera någon meningsfull data från - dess standarduttryck för att extrahera metadata är ``(?P<title>.+) - (?P<author>[^_]+)``. Ett reguljärt uttryck som fungerar här skulle vara ``[a-zA-Z]+: (?P<title>.+) by (?P<author>.+)``. Observera att du, inuti gruppen för metadatafältet, måste använda uttryck för att beskriva vad fältet faktiskt matchar. Och observera också att när du använder testfältet som calibre tillhandahåller måste du lägga till filändelsen till ditt testfilnamn, annars får du inga matchningar alls, trots att du använder ett fungerande uttryck.

en: Bulk editing metadata
sv: Redigera metadata i grupp

en: The last part is regular expression :guilabel:`Search and replace` in metadata fields. You can access this by selecting multiple books in the library and using bulk metadata edit. Be very careful when using this last feature, as it can do **Very Bad Things** to your library! Double-check that your expressions do what you want them to using the test fields, and only mark the books you really want to change! In the regular expression search mode, you can search in one field, replace the text with something and even write the result into another field. A practical example: Say your library contained the books of Frank Herbert's Dune series, named after the fashion ``Dune 1 - Dune``, ``Dune 2 - Dune Messiah`` and so on. Now you want to get ``Dune`` into the series field. You can do that by searching for ``(.*?) \d+ - .*`` in the title field and replacing it with ``\1`` in the series field. See what I did there? That's a reference to the first group you're replacing the series field with. Now that you have the series all set, you only need to do another search for ``.*? -`` in the title field and replace it with ``""`` (an empty string), again in the title field, and your metadata is all neat and tidy. Isn't that great? By the way, instead of replacing the entire field, you can also append or prepend to the field, so, if you *wanted* the book title to be prepended with series info, you could do that as well. As you by now have undoubtedly noticed, there's a checkbox labeled :guilabel:`Case sensitive`, so you won't have to use flags to select behaviour here.
sv: Den sista användningen är :guilabel:`Sök och ersätt` med reguljära uttryck i metadatafält. Du når funktionen genom att markera flera böcker i biblioteket och välja massredigering av metadata. Var mycket försiktig när du använder denna funktion, eftersom den kan göra **mycket stor skada** i biblioteket! Kontrollera med hjälp av testfälten att uttrycken gör precis det du avser, och markera endast de böcker som verkligen ska ändras. I sökläget för reguljära uttryck kan du söka i ett fält, ersätta texten och till och med skriva resultatet till ett annat fält. Ett praktiskt exempel: Anta att biblioteket innehåller böckerna i Frank Herberts Dune-serie med titlar som ``Dune 1 - Dune``, ``Dune 2 - Dune Messiah`` och så vidare. Du vill nu lägga in ``Dune`` i seriefältet. Sök då efter ``(.*?) \d+ - .*`` i titelfältet och ersätt med ``\1`` i seriefältet. Ser du vad som händer? ``\1`` är en referens till den första gruppen, vars innehåll skrivs till seriefältet. När serien är korrekt behöver du bara söka efter ``.*? -`` i titelfältet och ersätta det med ``""`` (en tom sträng), återigen i titelfältet. Därefter är dina metadata prydliga och konsekventa. Visst är det praktiskt? I stället för att ersätta hela fältet kan du även lägga till text i början eller slutet. Om du exempelvis *vill* lägga serieinformationen före boktiteln kan du göra det. Som du säkert redan har sett finns även kryssrutan :guilabel:`Skiftlägeskänslig`, så du behöver inte använda flaggor för att styra detta beteende.

en: Well, that just about concludes the very short introduction to regular expressions. Hopefully I'll have shown you enough to at least get you started and to enable you to continue learning by yourself- a good starting point would be the `Python documentation for regexps <https://docs.python.org/library/re.html>`_.
sv: Därmed är den här mycket korta introduktionen till reguljära uttryck nästan slut. Förhoppningsvis har du fått tillräckligt med kunskap för att komma igång och fortsätta lära dig på egen hand. En bra utgångspunkt är `Python-dokumentationen om reguljära uttryck <https://docs.python.org/library/re.html>`_.

en: One last word of warning, though: Regexps are powerful, but also really easy to get wrong. calibre provides really great testing possibilities to see if your expressions behave as you expect them to. Use them. Try not to shoot yourself in the foot. (God, I love that expression...). But should you, despite the warning, injure your foot (or any other body parts), try to learn from it.
sv: Ett sista varningens ord: Reguljära uttryck är kraftfulla, men det är också mycket lätt att göra fel. calibre har utmärkta testfunktioner som visar om uttrycken fungerar som du förväntar dig. Använd dem. Försök att inte skjuta dig själv i foten. (Jag älskar verkligen det uttrycket.) Om du trots varningen ändå skadar foten, eller någon annan kroppsdel, försök att lära dig av misstaget.

en: Quick reference
sv: Snabbreferens

en: Credits
sv: Medverkande

en: Thanks for helping with tips, corrections and such:
sv: Tack för hjälpen med tips, rättningar och sådant:

en: For more about regexps see `The Python User Manual <https://docs.python.org/library/re.html>`_. The actual regular expression library used by calibre is: `regex <https://bitbucket.org/mrabarnett/mrab-regex/src/hg/>`_ which supports several useful enhancements over the Python standard library one.
sv: Mer information om reguljära uttryck finns i `Python-dokumentationen <https://docs.python.org/library/re.html>`_. Det bibliotek för reguljära uttryck som faktiskt används av calibre är `regex <https://bitbucket.org/mrabarnett/mrab-regex/src/hg/>`_, som har flera användbara förbättringar jämfört med Pythons standardbibliotek.
