natgillin/translations-raw huggingface dataset:
Because letters and digits have a logical order, you can abbreviate those by specifying ranges of them: [a-c] is equal to [abc] and [0-9] is equal to [0123456789]. Combining these constructs, for example [a-fynot1-38] is completely legal (the last one would match, of cause, either of a, b, c, d, e, f, y, n, o, t, 1, 2, 3 or 8).
Eftersom bokstäver och siffror har en logisk ordning, kan du förkorta dem genom att ange intervall: [a- c] är samma sak som [abc] och [0- 9] är samma sak som [0123456789]. Att kombineras dessa sammansättningar, till exempel med [a- fynot1- 38] är fullständigt riktigt (detta skulle förstås matcha antingen a, b, c, d, e, f, y, n, o, t, 1, 2, 3 eller 8).
As capital letters are different characters from their non-capital equivalents, to create a caseless character class matching a or b, in any case, you need to write it [aAbB].
Eftersom stora bokstäver är andra tecken än motsvarande små bokstäver, så måste du alltså skriva [aAbB], för att skapa en teckenklass som matchar både de små och stora bokstäverna a eller b.
It is of cause possible to create a negative class matching as anything but To do so put a caret (^) at the beginning of the class:
Det är förstås möjligt att skapa en negativ klass som matchar allting utom. För att göra detta lägg till en hatt (^) först i klassen:
[^abc] will match any character but a, b or c.
[^abc] matchar alla tecken utom a, b eller c.
In addition to literal characters, some abbreviations are defined, making life still a bit easier:
Förutom uttryckliga tecken, definieras några förkortningar, som gör livet lite enklare:
This matches the ASCII bell character (BEL, 0x07).
Det här matchar ASCII - tecknet BEL (0x07).
This matches the ASCII form feed character (FF, 0x0C).
Det här matchar ASCII - tecknet ny sida (FF, 0x0C).
This matches the ASCII line feed character (LF, 0x0A, Unix newline).
Det här matchar ASCII - tecknet nyrad (LF, 0x0A, Unix nyrad).
This matches the ASCII carriage return character (CR, 0x0D).
Det här matchar ASCII returtecken (CR, 0x0D).
This matches the ASCII horizontal tab character (HT, 0x09).
Det här matchar ASCII - tecknet horisontell tabulator (HT, 0x09).
This matches the ASCII vertical tab character (VT, 0x0B).
Det här matchar ASCII - tecknet vertikal tabulator (VT, 0x0B).
This matches the Unicode character corresponding to the hexadecimal number hhhh (between 0x0000 and 0xFFFF). \\0ooo (ie;, \\zero ooo) matches the ASCII / Latin-1 character corresponding to the octal number ooo (between 0 and 0377).
Det här matchar Unicode- tecknet som motsvarar det hexadecimala värdet hhhh (mellan 0x0000 och 0xFFFF).\\ 0ooo (dvs.\ oll ooo) matchar ASCII / Latin- 1 tecknet som motsvarar det oktala värdet ooo (mellan 0 och 0377).
This matches any character (including newline).
Det här matchar vilket tecken som helst (inklusive nyrad).
This matches a digit. Equal to [0-9]
Det här matchar en siffra. Samma som [0- 9].
This matches a non-digit. Equal to [^0-9] or [^\\d]
Det här matchar allt utom en siffra. Samma som [^0- 9] eller [^\\ d].
This matches a whitespace character. Practically equal to [\\t\ \\r]
Det här matchar ett blanktecken. Nästan samma sak som [\\ t\\\ r].
This matches a non-whitespace. Practically equal to [^ \\t\\r\], and equal to [^\\s]
Det här matchar allt utom ett blanktecken. Nästan samma sak som [^\\ t\\ r\], och samma som [^\\ s].
Matches any word character - in this case any letter or digit. Note that underscore (_) is not matched, as is the case with perl regular expressions. Equal to [a-zA-Z0-9]
Matchar alla ord- tecken - i det här fallet alla bokstäver eller siffror. Observera att understreck (_) inte matchas, vilket är fallet för motsvarande reguljära uttryck i Perl. Samma som [a- zA- Z0- 9].
Matches any non-word character - anything but letters or numbers. Equal to [^a-zA-Z0-9] or [^\\w]
Matchar alla tecken som inte ingår i ord - allt utom bokstäver eller siffror. Samma som [^a- zA- Z0- 9] eller [^\\ w].
The abbreviated classes can be put inside a custom class, for example to match a word character, a blank or a dot, you could write [\\w\\.]
De förkortade klasserna kan användas inne i en annan klass. För att till exempel matcha ett ord- tecken, ett mellanslag eller en punkt, skulle du kunna skriva [\\ w\\.].
The POSIX notation of classes, [: lt; class namegt;:] is currently not supported.
POSIX- beskrivningen av klasser [: lt; klassnamngt;:] stöds inte för närvarande.
Characters with special meanings inside character classes
Tecken med särskild betydelse inne i teckenklasser
The following characters has a special meaning inside the [] character class construct, and must be escaped to be literally included in a class:
Följande tecken har en särskild betydelse inne i konstruktionen [] för teckenklasser, och måste undantas för att användas uttryckligen i en teckenklass:
Ends the character class. Must be escaped unless it is the very first character in the class (may follow an unescaped caret)
Avslutar teckenklassen. Måste undantas om det inte är det allra första tecknet i klassen (kan följa en hatt som inte undantas).
^ (caret)
^ (hatt)
Denotes a negative class, if it is the first character. Must be escaped to match literally if it is the first character in the class.
Anger en negativ klass, om det är det första tecknet. Måste undantas för att uttryckligen matcha om det är det första tecknet i klassen.
- (dash)
- (minus)
Denotes a logical range. Must always be escaped within a character class.
Anger ett logiskt intervall. Måste alltid undantas inne i en teckenklass.
\\ (backslash)
\\ (bakstreck)
The escape character. Must always be escaped.
Undantagstecknet. Måste alltid undantas.
Alternatives: matching one of
Alternativ: matchar en av
If you want to match one of a set of alternative patterns, you can separate those with _BAR_ (vertical bar character).
Om du vill matcha en av ett antal olika mönster, kan du skilja dem åt med _BAR_ (ett vertikalt streck).
For example to find either John or Harry you would use an expression John_BAR_Harry.
För att till exempel antingen hitta John eller Harry kan du använda uttrycket John_BAR_Harry.
Sub Patterns
Delmönster
Sub patterns are patterns enclosed in parentheses, and they have several uses in the world of regular expressions.
Delmönster är mönster som innesluts i parenteser, och som har flera användningar i de reguljära uttryckens värld.
Specifying alternatives
Ange alternativ
You may use a sub pattern to group a set of alternatives within a larger pattern. The alternatives are separated by the character _BAR_ (vertical bar).
Du kan använda ett delmönster för att gruppera ett antal alternativ i ett större mönster. Alternativen delas av tecknet _BAR_ (vertikalt streck).
For example to match either of the words int, float or double, you could use the pattern int_BAR_float_BAR_double. If you only want to find one if it is followed by some whitespace and then some letters, put the alternatives inside a subpattern: (int_BAR_float_BAR_double)\\s+\\w+.
För att till exempel matcha antingen orden int, float eller double, skulle du kunna använda mönstret int_BAR_float_BAR_double. Om du bara vill hitta ordet om det följs av blanktecken och därefter några bokstäver, placera alternativen i ett delmönster: (int_BAR_float_BAR_double)\\ s+\\ w+.
Capturing matching text (back references)
Spara text som matchar (bakåtreferenser)
If you want to use a back reference, use a sub pattern to have the desired part of the pattern remembered.
Om du vill använda en bakåtreferens, använd ett delmönster för att komma ihåg önskad del av mönstret.
For example, it you want to find two occurrences of the same word separated by a comma and possibly some whitespace, you could write (\\w+), \\s*\\1. The sub pattern \\w+ would find a chunk of word characters, and the entire expression would match if those were followed by a comma, 0 or more whitespace and then an equal chunk of word characters. (The string \\1 references the first sub pattern enclosed in parentheses)
Om du till exempel vill hitta två förekomster av samma ord åtskilda av ett kommatecken och möjligen några blanktecken, skulle du kunna skriva (\\ w+),\\ s *\\ 1. Delmönstret\\ w+ skulle hitta en grupp med ord- tecken, och hela uttrycket skulle matcha om de följdes av ett komma, noll eller flera blanktecken och sedan en likadan grupp med ord- tecken. (Strängen\\ 1 refererar till det första delmönstret inneslutet i parenteser).
Lookahead Assertions
Påståenden för sökning framåt
A lookahead assertion is a sub pattern, starting with either? = or?!.
Ett påstående för sökning framåt är ett delmönster, som antingen börjar med? = eller?!.
For example to match the literal string Bill but only if not followed by Gates, you could use this expression: Bill(?! Gates). (This would find Bill Clinton as well as Billy the kid, but silently ignore the other matches.)
För att till exempel uttryckligen matcha strängen Bill men bara om den inte följs av Gates, skulle du kunna använda det här uttrycket: Bill (?! Gates). (Det här skulle hitta Bill Clinton samt Billy the kid, men tyst ignorera de andra träffarna).
Sub patterns used for assertions are not captured.
Delmönster som används för påståenden sparas inte.
See also Assertions
Se också Påståenden.
Characters with a special meaning inside patterns
Tecken med särskild betydelse inne i mönster
The following characters have meaning inside a pattern, and must be escaped if you want to literally match them:
Följande tecken har särskild betydelse inne i mönster, och måste undantas om du uttryckligen vill matcha dem:
The escape character.
Undantagstecknet.
Asserts the beginning of the string.
Anger början på strängen.
Asserts the end of string.
Anger slutet på strängen.
() (left and right parentheses)
() (vänster och höger parentes)
Denotes sub patterns.
Anger delmönster.
{} (left and right curly braces)
{} (vänster och höger klammer)
Denotes numeric quantifiers.
Anger numerisk kvalificering.
[] (left and right square brackets)
[] (vänster och höger hakparentes)
Denotes character classes.
Anger teckenklasser.
_BAR_ (vertical bar)
_BAR_ (vertikalt streck)
logical OR. Separates alternatives.
Logiskt ELLER. Skiljer alternativ.
+ (plus sign)
+ (plustecken)
Quantifier, 1 or more.
Kvalificering, en eller flera.
* (asterisk)
* (asterisk)
Quantifier, 0 or more.
Kvalificering, noll eller flera.
? (question mark)
? (frågetecken)
An optional character. Can be interpreted as a quantifier, 0 or 1.
Ett extra tecken. Kan tolkas som en kvalificering, noll eller ett.
Quantifiers allows a regular expression to match a specified number or range of numbers of either a character, character class or sub pattern.
En kvalificering låter ett reguljärt uttryck antingen matcha ett angivet antal eller intervall av ett tecken, en teckenklass eller ett delmönster.
Quantifiers are enclosed in curly brackets ({and}) and have the general form {[minimum-occurrences][, [maximum-occurrences]]}
En kvalificering innesluts av klamrar ({och}) och har den allmänna formen {[minimalt antal] [, [maximalt antal]]}.
The usage is best explained by example:
Användningen förklaras bäst med exempel:
Exactly 1 occurrence
Exakt en förekomst
Zero or 1 occurrences
Noll eller en förekomst
The same, with less work;)
Samma sak, med mindre ansträngning;)
At least 5 but maximum 10 occurrences.
Minst 5 men maximalt 10 förekomster
At least 5 occurrences, no maximum.
Minst 5 förekomster, inget maximum
Additionally, there are some abbreviations:
Det finns dessutom några förkortningar:
similar to {0,}, find any number of occurrences.
liknar {0,}, hittar ett godtyckligt antal förekomster.
similar to {1,}, at least 1 occurrence.
liknar {1,}, åtminstone en förekomst.
similar to {0,1}, zero or 1 occurrence.
liknar {0, 1}, noll eller en förekomst.
Greed
Glupskt beteende
When using quantifiers with no maximum, regular expressions defaults to match as much of the searched string as possible, commonly known as greedy behaviour.
När kvalificeringar utan maximum används, så matchar reguljära uttryck normalt så mycket av söksträngen som möjligt, ett beteende som ofta kallas för glupskt.
Modern regular expression software provides the means of turning off greediness, though in a graphical environment it is up to the interface to provide you with access to this feature. For example a search dialogue providing a regular expression search could have a check box labelled Minimal matching as well as it ought to indicate if greediness is the default behaviour.
Modern programvara för reguljära uttryck tillhandahåller en möjlighet att stänga av det glupska beteendet, även om det är det grafiska gränssnittet som måste ge dig tillgång till den här funktionen. En sökdialogruta som tillhandahåller sökning med reguljära uttryck skulle kunna ha en kryssruta som heter Minimal matchning, och borde också ange att glupskt beteende är det normala.
In context examples
Exempel i sammanhang
Here are a few examples of using quantifiers
Här är några exempel på att använda kvalificering.
Matches the digits in 1234 go and 12345 now, but neither in 567 eleven nor in 223459 somewhere
Matchar siffrorna i 1234 gå och 12345 nu, men varken 567 elva eller 223459 någonstans.
Matches one or more whitespace characters
Matchar en eller flera blanktecken
Matches all of blablabla and the bla in blackbird or tabla
Matchar samtliga blablabla och bla i blad eller dubbla
Matches / gt; in lt; closeditem/ gt; as well as gt; in lt; openitemgt;.
Matchar / gt; i lt; slut/ gt; samt gt; i lt; startgt;.
Assertions allows a regular expression to match only under certain controlled conditions.
Påståenden gör att ett reguljärt uttryck bara matchar under vissa kontrollerade omständigheter.
An assertion does not need a character to match, it rather investigates the surroundings of a possible match before acknowledging it. For example the word boundary assertion does not try to find a non word character opposite a word one at its position, instead it makes sure that there is not a word character. This means that the assertion can match where there is no character, & ie; at the ends of a searched string.
Ett påstående behöver inte ett tecken för att matcha, utan undersöker istället omgivningen runt en möjlig matchning innan den erkänns. Påståendet ordgräns försöker till exempel inte hitta ett tecken som inte ingår i ett ord intill ett ord- tecken på platsen, utan kontrollerar istället att det inte finns ett ord- tecken. Det här betyder att påståendet matchar där det inte finns något tecken alls, dvs. vid slutet på söksträngen.
Some assertions actually does have a pattern to match, but the part of the string matching that will not be a part of the result of the match of the full expression.
Vissa påståenden har verkligen ett mönster som ska matcha, men den delen av strängen som matchar kommer inte att ingå i resultatet för matchningen av hela uttrycket.
Regular Expressions as documented here supports the following assertions:
Reguljära uttryck som de dokumenteras här stöder följande påståenden:
^ (caret: beginning of string)
^ (hatt: början på strängen)
Matches the beginning of the searched string.
Matchar början på söksträngen.
The expression ^Peter will match at Peter in the string Peter, hey! but not in Hey, Peter!
Uttrycket ^Peter matchar vid Peter i strängen Peter, hej då! men inte Hej, Peter!.
$(end of string)
$(slutet på strängen)
Matches the end of the searched string.
Matchar slutet på söksträngen.
The expression you\\? $will match at the last you in the string You did n't do that, did you? but nowhere in You did n't do that, right?
Uttrycket du\\? $matchar det sista du & # 160; i strängen Du gjorde det väl inte, eller var det verkligen du? men ingenstans i Du gjorde det väl inte, eller hur?.
\\b (word boundary)
\\ b (ordgräns)
Matches if there is a word character at one side and not a word character at the other.
Matchar om det finns ett ordtecken på ena sidan och något annat än ett ordtecken på andra sidan.
This is useful to find word ends, for example both ends to find a whole word. The expression \\bin\\b will match at the separate in in the string He came in through the window, but not at the in in window.
Det här är användbart för att hitta slutet på ord, till exempel för både början och slutet för att hitta ett helt ord. Uttrycket\\ bin\\ b matchar ett ensamt in i strängen Han kom in genom ingången, men inte det in som finns i ingången.
\\B (non word boundary)
\\ B (icke ordgräns)
Matches wherever \\b does not.
Matchar överallt där\\ b inte gör det.
That means that it will match for example within words: The expression \\Bin\\B will match at in window but not in integer or I 'm in love.
Det här betyder att det matchar till exempel inne i ord: Uttrycket\\ Bin\\ B matchar in i minne men inte i ingång eller Han kom in genom fönstret.
(? =PATTERN) (Positive lookahead)
(? =MÖNSTER) (Positiv sökning framåt)
A lookahead assertion looks at the part of the string following a possible match. The positive lookahead will prevent the string from matching if the text following the possible match does not match the PATTERN of the assertion, but the text matched by that will not be included in the result.
Ett påstående som söker framåt tittar på strängen som följer en möjlig matchning. Den positiva sökningen förhindrar att strängen matchar om inte texten som följer den möjliga matchningen matchar MÖNSTER i påståendet, men texten som matchas av det ingår inte i resultatet.
The expression handy(? =\\w) will match at handy in handyman but not in That came in handy!
Uttrycket vakt (? =\\ w) matchar för vakt in vaktmästare men inte i Han är en vakt!
(? !PATTERN) (Negative lookahead)
(?! MÖNSTER) (Negativ sökning framåt)
The negative lookahead prevents a possible match to be acknowledged if the following part of the searched string does match its PATTERN.
Den negativa sökningen framåt förhindrar en möjlig matchning från att bekräftas om den följande delen av söksträngen matchar sitt MÖNSTER.
The expression const \\w+\\b(? !\\s*amp;) will match at const char in the string const char* foo while it can not match const QString in const QStringamp; bar because the amp; matches the negative lookahead assertion pattern.
Uttrycket const\\ w+\\ b (?!\\ s* amp;) matchar vid const char i strängen const char * x medan den inte kan matcha const QString i const QStringamp; y eftersom amp; matchar mönstret i den negativa sökningen framåt.
The & kbugbuster; Handbook
Handbok & kbugbuster;
& kbugbuster; is part of the kdesdk package.
& kbugbuster; är en del av kdesdk- paketet.
The documentation for & kappname; was not finished when & kde; was installed on this computer.
Dokumentationen för & kbugbuster; var inte klar när & kde; installerades på den här datorn.
If you need help, please check The & kde; Website for updates, or by submitting your question to The & kde; User Mailing list.
Om du behöver hjälp, titta på kde;: s hemsida för uppdateringar, eller skicka din fråga till kde;: s e- postlista för användare.
The & kcachegrind; Handbook
Handbok & kcachegrind;
& kcachegrind; is a profile data visualisation tool, written using the & kde; environment.
& kcachegrind; är ett visualiseringsverktyg för profileringsdata, som är skrivet för & kde; - miljön.
& kappname; is a browser for data produced by profiling tools. This chapter explains what profiling is for, how it is done, and gives some examples of profiling tools available.
& kappname; är en bläddrare för data som producerats av profileringsverktyg. Det här kapitlet förklarar vad profilering är till för, hur den görs, och ger några exempel på tillgängliga profileringsverktyg.
When developing a program, one of the last steps often involves performance optimisations. As it makes no sense to optimise functions rarely used, because that would be a waste of time, one needs to know in which part of a program most of the time is spent.
När ett program utvecklas, omfattar ett av de sista stegen ofta prestandaoptimering. Eftersom det inte är vettigt att optimera funktioner som sällan används, vilket skulle vara bortkastad tid, måste man veta i vilka delar av programmet som den största delen av tiden går åt.
For sequential code, collecting statistical data of the programs runtime characteristic like time numbers spent in functions and code lines usually is enough. This is called Profiling. The program is run under control of a profiling tool, which gives the summary of an execution run at the end. In contrast, for parallel code, performance problems typically are caused when one processor is waiting for data from another. As this waiting time usually can not easily attributed, here it is better to generate timestamped event traces. KCachegrind can not visualise this kind of data.
För sekvensiell kod är det ofta tillräckligt att samla statistisk data om programmets beteende under körning, som åtgången tid i funktioner och per kodrad. Det kallas profilering. Programmet körs under övervakning av ett profileringsverktyg, som ger summeringen av en programkörning vid slutet. Däremot, för parallell kod, uppstår prestandaproblem oftast när en processor väntar på data från en annan. Eftersom väntetiden oftast inte enkelt kan fördelas, är det bättre att skapa tidsstämplade händelseföljder. & kcachegrind; kan inte visualisera den sortens data.
After analysing the produced profile data, it should be easy to see the hot spots and bottlenecks of the code: for example, assumptions about call counts can be checked, and identified code regions can be optimised. Afterwards, the success of the optimisation should be verified with another profile run.
Efter att ha analyserat skapad profileringsdata ska det vara enkelt att se utsatta ställen och flaskhalsar i koden. Till exempel kan antaganden om antal anrop kontrolleras, och identifierade kodavsnitt kan optimeras. Efteråt bör optimeringens resultat verifieras med ytterligare en profileringskörning.
Profiling Methods
Profileringsmetoder
To exactly measure the time passed or record the events happening during the execution of a code region (e. g. a function), additional measurement code needs to be inserted before and after the given region. This code reads the time, or a global event count, and calculates differences. Thus, the original code has to be changed before execution. This is called instrumentation. Instrumentation can be done by the programmer itself, the compiler, or by the runtime system. As interesting regions usually are nested, the overhead of measurement always influences the measurement itself. Thus, instrumentation should be done selectively and results have to be interpreted with care. Of course, this makes performance analysis by exact measurement a very complex process.
För att exakt mäta tiden som går eller spela in händelser som inträffar under körning av ett kodavsnitt (t. ex. en funktion) krävs att ytterligare uppmätningskod infogas innan och efter det givna området. Den här koden läser tiden eller en global händelseräknare, och beräknar skillnader. Alltså måste originalkoden ändras innan körning. Det kallas instrumentering. Instrumentering kan göras av programmeraren själv, av kompilatorn eller av körningssystemet. Eftersom intressanta områden ofta är i flera nivåer, påverkar tiden som går åt för mätningen alltid mätresultatet. Därför måste instrumentering göras selektivt och resultaten måste tolkas noggrant. Detta gör förstås prestandaanalys med exakta mätningar till en mycket komplex process.