xz-man

XZ

XZ

CompMem contains the compressor memory requirements in the single-threaded mode.  It may vary slightly between B<xz> versions.

KompMem innehåller komprimerarens minneskrav i enkeltrådat läge. Det kan variera något mellan versioner av B<xz>.

Add the Delta filter to the filter chain.  The Delta filter can be only used as a non-last filter in the filter chain.

Lägg till Deltafiltret till filterkedjan. Deltafiltret kan inte användas som det sista filtret i filterkedjan.

ENVIRONMENT

MILJÖ

B<more>(1), B<xz>(1), B<xzless>(1), B<zmore>(1)

B<more>(1), B<xz>(1), B<xzless>(1), B<zmore>(1)

Currency format may need localization

\f(CRxz --robot --list *.xz | awk '/^totals/{print $5-$4}'\fR

\f(CRxz --robot --list *.xz | awk '/^totals/{print $5-$4}'\fR

Duplicate word: 'med'

These are like B<-6> but with higher compressor and decompressor memory requirements.  These are useful only when compressing files bigger than 8\ MiB, 16\ MiB, and 32\ MiB, respectively.

Dessa liknar B<-6> med med högre krav på minne till komprimerare och dekomprimerare. Dessa är bara användbara vid komprimering av filer större än 8\ MiB, 16\ MiB respektive 32\ MiB.

Duplicate word: 'nästa'

DecMem contains the decompressor memory requirements.  That is, the compression settings determine the memory requirements of the decompressor.  The exact decompressor memory usage is slightly more than the LZMA2 dictionary size, but the values in the table have been rounded up to the next full MiB.

DekMin innehåller dekomprimerarens minneskrav. Det vill säga, komprimerarens inställningar avgör minneskravet för dekomprimeraren. Den exakta minnesanvändningen hos dekomprimeraren är något mer än LZMA2-lexikonstorleken, men värdena i tabellen har avrundats upp till nästa nästa hela MiB.

Duplicate word: 'en'

Specify the full filter chain or a preset in a single option.  Each filter can be separated by spaces or two dashes (B<-->).  I<filters> may need to be quoted on the shell command line so it is parsed as a single option.  To denote I<options>, use B<:> or B<=>.  A preset can be prefixed with a B<-> and followed with zero or more flags.  The only supported flag is B<e> to apply the same options as B<--extreme>.

Ange den fullständiga filterkedan eller en förinställning en en enda flagga. Varje filter kan separeras med blanktecken eller två bindestreck (B<-->). I<filter> kan behöva citeras på skalets kommandorad så att det tolkas som en enda flagga. För att beteckna I<flaggor>, använd B<:> eller B<=>. En förinställning kan föregås med ett B<-> och följas av noll eller flera flaggor. Den enda flaggan som stödjs är B<e> för att tillämpa samma flaggor som B<--extreme>.

Duplicate word: 'beta'

Stability.  0 is alpha, 1 is beta, and 2 is stable.  I<S> should be always 2 when I<YYY> is even.

Stabilitet.  0 är alfa, 1 beta beta och 2 är stabil. I<S> skall alltid vara 2 när I<YYY> är jämnt.

Use typographic ellipsis (…) instead of three dots (...)

The CompCPU columns of the tables from the descriptions of the options B<-0> ... B<-9> and B<--extreme> are useful when customizing LZMA2 presets.  Here are the relevant parts collected from those two tables:

Kolumnerna CompCPU i tabellerna från beskrivningen av flaggorna options B<-0> ... B<-9> och B<--extreme> är användbara vid anpassning av LZMA2-förinställningar. Här är de relevanta delarna samlade från dessa två tabeller:

Source ends with period but translation does not

Don't verify the integrity check of the compressed data when decompressing.  The CRC32 values in the B<.xz> headers will still be verified normally.

Verifiera inte integritetskontrollen av den komprimerade datan vid dekomprimering. CRC32-värden i B<.xz>-huvudena kommer fortfarande verifieras normalt

Source ends with period but translation does not

Compression I<mode> specifies the method to analyze the data produced by the match finder.  Supported I<modes> are B<fast> and B<normal>.  The default is B<fast> for I<presets> 0\(en3 and B<normal> for I<presets> 4\(en9.

KomprimeringsI<läget> anger metoden som används för att analysera data skapade av matchsökaren. De I<lägen> som stödjs är B<fast> och B<normal>. Standardvärdet är B<fast> för I<förinställningarna> 0\(en3 och B<normal> för I<förinställningarna> 4\(en9

False friend: 'actual' should be 'faktisk/verklig', not 'aktuell'

Specify the number of worker threads to use.  Setting I<threads> to a special value B<0> makes B<xz> use up to as many threads as the processor(s) on the system support.  The actual number of threads can be fewer than I<threads> if the input file is not big enough for threading with the given settings or if using more threads would exceed the memory usage limit.

Ange antalet arbetstrådar som skall användas. Att sätta I<trådar> till ett specialvärde B<0> gör att B<xz> använder så många trådar som processorerna på systemet stödjer. Det aktuella antalet trådar kan vara färre än I<trådar> om indatafilen inte är stor nog för trådning med de givna inställningarna eller om användning av fler trådar skulle överkrida gränsen för minnesanvändning.

Missing ending punctuation (source ends with '.')

Don't verify the integrity check of the compressed data when decompressing.  The CRC32 values in the B<.xz> headers will still be verified normally.

Verifiera inte integritetskontrollen av den komprimerade datan vid dekomprimering. CRC32-värden i B<.xz>-huvudena kommer fortfarande verifieras normalt

Missing ending punctuation (source ends with '.')

Compression I<mode> specifies the method to analyze the data produced by the match finder.  Supported I<modes> are B<fast> and B<normal>.  The default is B<fast> for I<presets> 0\(en3 and B<normal> for I<presets> 4\(en9.

KomprimeringsI<läget> anger metoden som används för att analysera data skapade av matchsökaren. De I<lägen> som stödjs är B<fast> och B<normal>. Standardvärdet är B<fast> för I<förinställningarna> 0\(en3 och B<normal> för I<förinställningarna> 4\(en9

Keyboard accelerator missing in translation

\f(CRxz --lzma2=preset=6e,pb=0,lc=4 source_code.tar\fR

\f(CRxz --lzma2=preset=6e,pb=0,lc=4 källkod.tar\fR

Keyboard accelerator missing in translation

B<xzgrep> [I<option...>] [I<pattern_list>] [I<file...>]

B<xzgrep> [I<flagga…>] [I<mönsterlista>] [I<fil…>]

Numbers {'6'} from source missing in translation

Memory requirements of the multi-threaded mode are significantly higher than that of the single-threaded mode.  With the default value of B<--block-size>, each thread needs 3*3*DictSize plus CompMem or DecMem.  For example, four threads with preset B<-6> needs 660\(en670\ MiB of memory.

Minneskravet för det multitrådade läget är signifikant högre än det för enkeltrådat läge. Med standardvärdet på B<--block-size> behöver varje tråd 3·3·LexStrl plus KompMin eller DekMin. Till exempel, fyra trådar med förinställningen behöver 660\(en670 MiB minne.

Numbers {'5.5'} from source missing in translation

I<dict> * 5.5 + 64 MiB (if I<dict> E<gt> 16 MiB)

I<dict> · 5,5 + 64 MiB (om I<dict> E<gt> 16 MiB)

Numbers {'7.5'} from source missing in translation

I<dict> * 7.5 (if I<dict> E<lt>= 32 MiB);

I<dict> · 7,5 (om I<dict> ≤ 32 MiB);

Numbers {'6.5'} from source missing in translation

I<dict> * 6.5 (if I<dict> E<gt> 32 MiB)

I<dict> · 6,5 (om I<dict> E<gt> 32 MiB)

Numbers {'9.5'} from source missing in translation

Memory usage: I<dict> * 9.5

Minnesanvändning: I<dict> · 9,5

Numbers {'11.5'} from source missing in translation

I<dict> * 11.5 (if I<dict> E<lt>= 16 MiB);

I<dict> · 11,5 (om I<dict> ≤ 16 MiB);

Numbers {'9.5'} from source missing in translation

I<dict> * 9.5 + 64 MiB (if I<dict> E<gt> 16 MiB)

I<dict> · 9,5 + 64 MiB (om I<dict> E<gt> 16 MiB)

Numbers {'11.5'} from source missing in translation

I<dict> * 11.5 (if I<dict> E<lt>= 32 MiB);

I<dict> · 11,5 (om I<dict> ≤ 32 MiB);

Numbers {'10.5'} from source missing in translation

I<dict> * 10.5 (if I<dict> E<gt> 32 MiB)

I<dict> · 10,5 (om I<dict> E<gt> 32 MiB)

Numbers {'20', '2'} from source missing in translation

B<lzmainfo> uses B<MB> while the correct suffix would be B<MiB> (2^20 bytes).  This is to keep the output compatible with LZMA Utils.

B<lzmainfo> använder B<MB> medan det korrekta suffixet vore B<MiB> (2²⁰ byte). Detta är för att behålla utdata kompatibel med LZMA Utils.

Missing Plural-Forms header for Swedish (expected nplurals=2)

Plural-Forms header

Repeated word: 'med'

These are like B<-6> but with higher compressor and decompressor memory requirements.  These are useful only when compressing files bigger than 8\ MiB, 16\ MiB, and 32\ MiB, respectively.

Dessa liknar B<-6> med med högre krav på minne till komprimerare och dekomprimerare. Dessa är bara användbara vid komprimering av filer större än 8\ MiB, 16\ MiB respektive 32\ MiB.

Repeated word: 'nästa'

DecMem contains the decompressor memory requirements.  That is, the compression settings determine the memory requirements of the decompressor.  The exact decompressor memory usage is slightly more than the LZMA2 dictionary size, but the values in the table have been rounded up to the next full MiB.

DekMin innehåller dekomprimerarens minneskrav. Det vill säga, komprimerarens inställningar avgör minneskravet för dekomprimeraren. Den exakta minnesanvändningen hos dekomprimeraren är något mer än LZMA2-lexikonstorleken, men värdena i tabellen har avrundats upp till nästa nästa hela MiB.

Repeated word: 'i'

If the input file is bigger than the sum of the sizes in I<items>, the last item is repeated until the end of the file.  A special value of B<0> may be used as the last size to indicate that the rest of the file should be encoded as a single block.

Om indatafiler är större än summan av storlekarna i I<poster> repeteras den sista posten fram till slutet på filen. Ett speciellt värde B<0> kan användas som den sista storleken för att indikera att resten av filen skall kodas som ett enda block.

Repeated word: 'i'

If one specifies a size that exceeds the encoder's block size (either the default value in threaded mode or the value specified with B<--block-size=>I<size>), the encoder will create additional blocks while keeping the boundaries specified in I<items>.  For example, if one specifies B<--block-size=10MiB> B<--block-list=5MiB,10MiB,8MiB,12MiB,24MiB> and the input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB.

Om man anger en storlek som överskrider kodarens blockstorlek (antingen standardvärdet i trådat läge eller värdet som anges med B<--block-size=>I<storlek>) kommer kodaren skapa ytterligare block med hänsyn taget till gränserna som anges i I<poster>. Till exempel, om man anger B<--block-size=10MiB> B<--block-list=5MiB,10MiB,8MiB,12MiB,24MiB> och indatafilen är 80 MiB kommer man få 11 block: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 och 1 MiB.

Repeated word: 'en'

Specify the full filter chain or a preset in a single option.  Each filter can be separated by spaces or two dashes (B<-->).  I<filters> may need to be quoted on the shell command line so it is parsed as a single option.  To denote I<options>, use B<:> or B<=>.  A preset can be prefixed with a B<-> and followed with zero or more flags.  The only supported flag is B<e> to apply the same options as B<--extreme>.

Ange den fullständiga filterkedan eller en förinställning en en enda flagga. Varje filter kan separeras med blanktecken eller två bindestreck (B<-->). I<filter> kan behöva citeras på skalets kommandorad så att det tolkas som en enda flagga. För att beteckna I<flaggor>, använd B<:> eller B<=>. En förinställning kan föregås med ett B<-> och följas av noll eller flera flaggor. Den enda flaggan som stödjs är B<e> för att tillämpa samma flaggor som B<--extreme>.

Repeated word: 'beta'

Stability.  0 is alpha, 1 is beta, and 2 is stable.  I<S> should be always 2 when I<YYY> is even.

Stabilitet.  0 är alfa, 1 beta beta och 2 är stabil. I<S> skall alltid vara 2 när I<YYY> är jämnt.

Translation is identical to source (possibly untranslated)

256 KiB

256 KiB

Translation is identical to source (possibly untranslated)

3 MiB

3 MiB

Translation is identical to source (possibly untranslated)

1 MiB

1 MiB

Translation is identical to source (possibly untranslated)

9 MiB

9 MiB

Translation is identical to source (possibly untranslated)

2 MiB

2 MiB

Translation is identical to source (possibly untranslated)

17 MiB

17 MiB

Translation is identical to source (possibly untranslated)

4 MiB

4 MiB

Translation is identical to source (possibly untranslated)

32 MiB

32 MiB

Translation is identical to source (possibly untranslated)

5 MiB

5 MiB

Translation is identical to source (possibly untranslated)

48 MiB

48 MiB

Translation is identical to source (possibly untranslated)

8 MiB

8 MiB

Translation is identical to source (possibly untranslated)

94 MiB

94 MiB

Translation is identical to source (possibly untranslated)

16 MiB

16 MiB

Translation is identical to source (possibly untranslated)

186 MiB

186 MiB

Translation is identical to source (possibly untranslated)

370 MiB

370 MiB

Translation is identical to source (possibly untranslated)

33 MiB

33 MiB

Translation is identical to source (possibly untranslated)

64 MiB

64 MiB

Translation is identical to source (possibly untranslated)

674 MiB

674 MiB

Translation is identical to source (possibly untranslated)

65 MiB

65 MiB

Translation is identical to source (possibly untranslated)

13 MiB

13 MiB

Translation is identical to source (possibly untranslated)

25 MiB

25 MiB

Translation is identical to source (possibly untranslated)

64 KiB

64 KiB

Translation is identical to source (possibly untranslated)

512 KiB

512 KiB

Translation is identical to source (possibly untranslated)

LZMA Utils 4.32.x

LZMA Utils 4.32.x

Translation is identical to source (possibly untranslated)

12 MiB

12 MiB

Translation is identical to source (possibly untranslated)

26 MiB

26 MiB

Translation is identical to source (possibly untranslated)

45 MiB

45 MiB

Translation is identical to source (possibly untranslated)

83 MiB

83 MiB

Translation is identical to source (possibly untranslated)

159 MiB

159 MiB

Translation is identical to source (possibly untranslated)

311 MiB

311 MiB

XML/HTML tags mismatch: source has ['<file>', '<option>', '<xz>'], translation has ['<fil>', '<flagga>', '<xz>']

B<xz> [I<option...>] [I<file...>]

B<xz> [I<flagga…>] [I<fil…>]

XML/HTML tags mismatch: source has ['<file>', '<file>', '<file>', '<files>', '<xz>', '<xz>', '<xz>', '<xz>'], translation has ['<fil>', '<fil>', '<filen>', '<filer>', '<xz>', '<xz>', '<xz>', '<xz>']

B<xz> compresses or decompresses each I<file> according to the selected operation mode.  If no I<files> are given or I<file> is B<->, B<xz> reads from standard input and writes the processed data to standard output.  B<xz> will refuse (display an error and skip the I<file>)  to write compressed data to standard output if it is a terminal.  Similarly, B<xz> will refuse to read compressed data from standard input if it is a terminal.

B<xz> komprimerar och dekomprimerar varje I<fil> i enlighet med det valda arbetsläget. Om inga I<filer> anges eller I<fil> är B<-> läser B<xz> från standard in och skriver den behandade datan på standard ut. B<xz> kommer vägra (visa ett felmeddelande och hoppa över I<filen>) att skriva komprimerad data direkt till standard ut om det är en terminal. På samma sätt kommer B<xz> vägra att läsa komprimerade data från standard in om det är en terminal.

XML/HTML tags mismatch: source has ['<file>', '<files>'], translation has ['<filens>', '<filer>']

Unless B<--stdout> is specified, I<files> other than B<-> are written to a new file whose name is derived from the source I<file> name:

Om inte B<--stdout> anges skrivs andra I<filer> än B<-> till en ny fil vars namn härleds från källI<filens> namn:

XML/HTML tags mismatch: source has ['<file>'], translation has ['<filen>']

If the target file already exists, an error is displayed and the I<file> is skipped.

Om målfilen redan finns visas ett felmeddelande och I<filen> hoppas över.

XML/HTML tags mismatch: source has ['<file>', '<xz>'], translation has ['<filen>', '<xz>']

Unless writing to standard output, B<xz> will display a warning and skip the I<file> if any of the following applies:

Utom när den skriver till standard ut kommer B<xz> visa en varning och hoppa över I<filen> om något av följande inträffar:

XML/HTML tags mismatch: source has ['<File>'], translation has ['<Fil>']

I<File> is not a regular file.  Symbolic links are not followed, and thus they are not considered to be regular files.

I<Fil> är inte en vanlig fil. Symboliska länkar följs inte, och därför anses de inte vara vanliga filer.

XML/HTML tags mismatch: source has ['<File>'], translation has ['<Fil>']

I<File> has more than one hard link.

I<Fil> har mer än en hård länk.

XML/HTML tags mismatch: source has ['<File>'], translation has ['<Fil>']

I<File> has setuid, setgid, or sticky bit set.

I<Fil> har biten setuid, setgid eller sticky satt.

XML/HTML tags mismatch: source has ['<file>'], translation has ['<filen>']

The operation mode is set to compress and the I<file> already has a suffix of the target file format (B<.xz> or B<.txz> when compressing to the B<.xz> format, and B<.lzma> or B<.tlz> when compressing to the B<.lzma> format).

Arbetsläget är satt till att komprimera och I<filen> har redan ett suffix enligt målfilformatet (B<.xz> eller B<.txz> vid komprimering till formatet B<.xz>, och B<.lzma> eller B<.tlz> vid komprimering till formatet B<.lzma>).

XML/HTML tags mismatch: source has ['<file>'], translation has ['<filen>']

The operation mode is set to decompress and the I<file> doesn't have a suffix of any of the supported file formats (B<.xz>, B<.txz>, B<.lzma>, B<.tlz>, or B<.lz>).

Arbetsläget är satt till att dekomprimera och I<filen> har inte ett suffix enligt något av de stödda filformaten (B<.xz>, B<.txz>, B<.lzma>, B<.tlz> eller B<.lz>).

XML/HTML tags mismatch: source has ['<file>', '<file>', '<file>', '<xz>', '<xz>'], translation has ['<filen>', '<filen>', '<filen>', '<xz>', '<xz>']

After successfully compressing or decompressing the I<file>, B<xz> copies the owner, group, permissions, access time, and modification time from the source I<file> to the target file.  If copying the group fails, the permissions are modified so that the target file doesn't become accessible to users who didn't have permission to access the source I<file>.  B<xz> doesn't support copying other metadata like access control lists or extended attributes yet.

Efter att ha kunnat komprimera eller dekomprimera I<filen> kopierar B<xz> ägaren, gruppen, rättigheterna, åtkomsttiden och ändringstiden från källI<filen> till målfilen. Om kopieringen av grupp misslyckas ändras rättigheterna så att målfilen inte blir åtkomlig för användare som inte har rättigheter att komma åt källI<filen>. B<xz> stödjer inte kopiering av annan metadata såsom åtkomststyrhingslistor eller utökade attribut ännu.

XML/HTML tags mismatch: source has ['<file>', '<file>'], translation has ['<filen>', '<filen>']

Once the target file has been successfully closed, the source I<file> is removed unless B<--keep> was specified.  The source I<file> is never removed if the output is written to standard output or if an error occurs.

När målfilen har stängts framgångsrikt tas källI<filen> bort såvida inte B<--keep> angavs. KällI<filen> tas aldrig bort om utdata skrevs till standard ut eller om något fel inträffade.

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<limit>', '<limit>', '<limit>', '<xz>'], translation has ['<limit>', '<limit>', '<xz>']

The memory usage limiter can be enabled with the command line option B<--memlimit=>I<limit>.  Often it is more convenient to enable the limiter by default by setting the environment variable B<XZ_DEFAULTS>, for example, B<XZ_DEFAULTS=--memlimit=150MiB>.  It is possible to set the limits separately for compression and decompression by using B<--memlimit-compress=>I<limit> and B<--memlimit-decompress=>I<limit>.  Using these two options outside B<XZ_DEFAULTS> is rarely useful because a single run of B<xz> cannot do both compression and decompression and B<--memlimit=>I<limit> (or B<-M> I<limit>)  is shorter to type on the command line.

Minnesanvändningsbegränsaren kan aktiveras med kommandoradsflaggan B<--memlimit=>I<gräns>. Ofta är det bekvämare att aktivera begränsaren som standard genom att sätta miljövariabeln B<XZ_DEFAULTS>, till exempel, B<XZ_DEFAULTS=--memlimit=150MiB>. Det är möjligt att sätta gränser separat för komprimering och dekomprimering genom att använda B<--memlimit-compress=>I<limit> och B<--memlimit-decompress=>I<limit>. Att använda dessa två flaggor utanför B<XZ_DEFAULTS> är sällan meningsfullt eftersom en enskild körning av B<xz> inte kan göra både komprimering och dekomprimering och and B<--memlimit=>I<gräns> (eller B<-M> I<gräns>) är kortare att skriva på kommandoraden.

XML/HTML tags mismatch: source has ['<files>'], translation has ['<filer>']

Test the integrity of compressed I<files>.  This option is equivalent to B<--decompress --stdout> except that the decompressed data is discarded instead of being written to standard output.  No files are created or removed.

Testa integriteten hos komprimerade I<filer>. Denna flagga är ekvivalent med B<--decompress --stdout> förutom att den dekomprimerade datan slängs istället för att skrivas på standard ut. Inga filer skapas eller tas bort.

XML/HTML tags mismatch: source has ['<files>'], translation has ['<filer>']

Print information about compressed I<files>.  No uncompressed output is produced, and no files are created or removed.  In list mode, the program cannot read the compressed data from standard input or from other unseekable sources.

Skriv information om komprimerade I<filer>. Inge dekomprimeringsutdata skapas, och inga filer skapas eller tas bort. I listläge kan programmet inte läsa komprimerad data från standard in eller från andra källor där man inte kan söka.

XML/HTML tags mismatch: source has ['<files>', '<less>'], translation has ['<filer>', '<less>']

The default listing shows basic information about I<files>, one file per line.  To get more detailed information, use also the B<--verbose> option.  For even more information, use B<--verbose> twice, but note that this may be slow, because getting all the extra information requires many seeks.  The width of verbose output exceeds 80 characters, so piping the output to, for example, B<less\ -S> may be convenient if the terminal isn't wide enough.

Standardlistningen visar grundläggande information om I<filer>, en fil per rad. För att få mer detaljerad information, använd även flaggan B<--verbose>. För ännu mer information, använd B<--verbose> två gånger, men observera att detta kan vara långsamt, eftersom det behövs många sökningar får att samla all den extra informationen. Bredden av utförlig utdata överskrider 80 tecken, så att skicka utdata i ett rör till, till exempel, B<less\ -S> kan vara bekvämt om terminalen inte är bred nog.

XML/HTML tags mismatch: source has ['<file>'], translation has ['<fil>']

B<--files>[B<=>I<file>]

B<--files>[B<=>I<fil>]

XML/HTML tags mismatch: source has ['<file>', '<file>', '<file>'], translation has ['<fil>', '<fil>', '<fil>']

Read the filenames to process from I<file>; if I<file> is omitted, filenames are read from standard input.  Filenames must be terminated with the newline character.  A dash (B<->)  is taken as a regular filename; it doesn't mean standard input.  If filenames are given also as command line arguments, they are processed before the filenames read from I<file>.

Läs filnamnen att arbeta på från I<fil>; om I<fil> utelämnas läses filnamn från standard in. Filnamn måste avslutas med nyradstecknet. Ett bindestreck (B<->) tas som ett vanligt filnamn; det betyder inte standard in. Om filnamn även anges som kommandoradsargument, bearbetas de före filnamnen som läses från I<fil>.

XML/HTML tags mismatch: source has ['<file>'], translation has ['<fil>']

B<--files0>[B<=>I<file>]

B<--files0>[B<=>I<fil>]

XML/HTML tags mismatch: source has ['<file>'], translation has ['<fil>']

This is identical to B<--files>[B<=>I<file>] except that each filename must be terminated with the null character.

Detta är identiskt med B<--files>[B<=>I<fil>] förjutom att varje filnamn måste avslutas med ett nulltecken.

XML/HTML tags mismatch: source has ['<check>', '<check>'], translation has ['<kontroll>', '<kontroll>']

B<-C> I<check>, B<--check=>I<check>

B<-C> I<kontroll>, B<--check=>I<kontroll>

XML/HTML tags mismatch: source has ['<check>'], translation has ['<Kontroll>']

Supported I<check> types:

I<Kontroll>typer som stödjs:

XML/HTML tags mismatch: source has ['<Do>'], translation has []

B<Do not use this option unless you know what you are doing.> Possible reasons to use this option:

B<Använd inte denna flagga om du inte vet vad du gör.> Möjliga anledningar till att använda denna flagga:

XML/HTML tags mismatch: source has ['<bzip2>', '<bzip2>', '<gzip>', '<gzip>', '<it>'], translation has ['<bzip2>', '<bzip2>', '<gzip>', '<gzip>']

The differences between the presets are more significant than with B<gzip>(1)  and B<bzip2>(1).  The selected compression settings determine the memory requirements of the decompressor, thus using a too high preset level might make it painful to decompress the file on an old system with little RAM.  Specifically, B<it's not a good idea to blindly use -9 for everything> like it often is with B<gzip>(1)  and B<bzip2>(1).

Skillnaden mellan förinställningarna har större betydelse än med B<gzip>(1) och B<bzip2>(1). Den valda komprimeringsinställningen avgör minneskraven för dekomprimeraren, att använda en för hög förinställningsnivå kan alltså göra det plågsamt att dekomprimera filer på ett gammalt system med lite RAM. Specifikt B<är det inte en bra ide att blint använda -9 för allt> liksom det ofta är med B<gzip>(1) och B<bzip2>(1).

XML/HTML tags mismatch: source has ['<size>'], translation has ['<storlek>']

B<--block-size=>I<size>

B<--block-size=>I<storlek>

XML/HTML tags mismatch: source has ['<size>'], translation has ['<storlek>']

When compressing to the B<.xz> format, split the input data into blocks of I<size> bytes.  The blocks are compressed independently from each other, which helps with multi-threading and makes limited random-access decompression possible.  This option is typically used to override the default block size in multi-threaded mode, but this option can be used in single-threaded mode too.

Vid komprimering till formatet B<.xz>, dela indatai block med I<storlek> bytes. Blocken komprimeras oberoende av varandra, vilket hjälper till vid multitrådning  och gör begränsad random-access-dekomprimering möjlig. Denna flagga används typiskt för att åsidosätta blockstorleken i multitrådat läge, men denna flagga kan användas även i enkeltrådat läge.

XML/HTML tags mismatch: source has ['<size>', '<size>', '<size>'], translation has ['<storlek>', '<storlek>', '<storlek>']

In multi-threaded mode about three times I<size> bytes will be allocated in each thread for buffering input and output.  The default I<size> is three times the LZMA2 dictionary size or 1 MiB, whichever is more.  Typically a good value is 2\(en4 times the size of the LZMA2 dictionary or at least 1 MiB.  Using I<size> less than the LZMA2 dictionary size is waste of RAM because then the LZMA2 dictionary buffer will never get fully used.  In multi-threaded mode, the sizes of the blocks are stored in the block headers.  This size information is required for multi-threaded decompression.

I multitrådat läge kommer ungefär tre gånger I<storlek> byte att allokeras i varje tråd för buffring av indata och utdata. Standardvärdet på I<storlek> är det större av tre gånger LZMA2-lexikonstorleken eller 1 MiB. Typiskt är ett bra värde 2\(en4 gånger storleken på LZMA2-lexikonet eller åtminstone 1 MiB. Att använda en I<storlek> mindre än LZMA2-lexikonstorleken utgör slöseri med RAM eftersom LZMA2-lexikonbufferten då aldrig kommer användas helt. I multitrådat läge lagras storlekarna på plocken i blockhuvudena. Denna storleksinformation krävs för multitrådad dekomprimering.

XML/HTML tags mismatch: source has ['<items>'], translation has ['<poster>']

B<--block-list=>I<items>

B<--block-list=>I<poster>

XML/HTML tags mismatch: source has ['<items>'], translation has ['<Posterna>']

The I<items> are a comma-separated list.  Each item consists of an optional filter chain number between 0 and 9 followed by a colon (B<:>)  and a required size of uncompressed data.  Omitting an item (two or more consecutive commas) is a shorthand to use the size and filters of the previous item.

I<Posterna> är en kommaseparerad lista. Varje post består av ett möjligt filterkedjenummer mellan 0 och 9 följt av ett kolon (B<:>) och en obligatorisk storlek för okomprimerade data. Att utelämna en post (två på varandra följande komman) är en kortform för att använda storleken och filtren från föregående post.

XML/HTML tags mismatch: source has ['<items>'], translation has ['<poster>']

If the input file is bigger than the sum of the sizes in I<items>, the last item is repeated until the end of the file.  A special value of B<0> may be used as the last size to indicate that the rest of the file should be encoded as a single block.

Om indatafiler är större än summan av storlekarna i I<poster> repeteras den sista posten fram till slutet på filen. Ett speciellt värde B<0> kan användas som den sista storleken för att indikera att resten av filen skall kodas som ett enda block.

XML/HTML tags mismatch: source has ['<filters>', '<filters>'], translation has ['<filter>', '<filter>']

An alternative filter chain for each block can be specified in combination with the B<--filters1=>I<filters> \&...\& B<--filters9=>I<filters> options.  These options define filter chains with an identifier between 1\(en9.  Filter chain 0 can be used to refer to the default filter chain, which is the same as not specifying a filter chain.  The filter chain identifier can be used before the uncompressed size, followed by a colon (B<:>).  For example, if one specifies B<--block-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB> then blocks will be created using:

En alternativ filterkedja för varje block kan anges i kombinaton med flaggorna B<--filters1=>I<filter> \&…\& B<--filters9=>I<filter>. Dessa flaggor definierar filterkedjor med en identifierare mellan 1\(en9. Filterkedja 0 kan användas för att referera till standardfilterkedjan, vilket är samma sak som att inte ange någon filterkedja. Filterkedjeidentifierare kan användas före den okomprimerade sotrleken, följt av ett kolon (B<:>). Till exempel, om man anger B<--block-list=1:2MiB,3:2MiB,2:4MiB,,2MiB,0:4MiB> kommer block skapas med:

XML/HTML tags mismatch: source has ['<items>', '<size>'], translation has ['<poster>', '<storlek>']

If one specifies a size that exceeds the encoder's block size (either the default value in threaded mode or the value specified with B<--block-size=>I<size>), the encoder will create additional blocks while keeping the boundaries specified in I<items>.  For example, if one specifies B<--block-size=10MiB> B<--block-list=5MiB,10MiB,8MiB,12MiB,24MiB> and the input file is 80 MiB, one will get 11 blocks: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10, and 1 MiB.

Om man anger en storlek som överskrider kodarens blockstorlek (antingen standardvärdet i trådat läge eller värdet som anges med B<--block-size=>I<storlek>) kommer kodaren skapa ytterligare block med hänsyn taget till gränserna som anges i I<poster>. Till exempel, om man anger B<--block-size=10MiB> B<--block-list=5MiB,10MiB,8MiB,12MiB,24MiB> och indatafilen är 80 MiB kommer man få 11 block: 5, 10, 8, 10, 2, 10, 10, 4, 10, 10 och 1 MiB.

XML/HTML tags mismatch: source has ['<timeout>'], translation has []

B<--flush-timeout=>I<timeout>

B<--flush-timeout=>I<tidsgräns>

XML/HTML tags mismatch: source has ['<timeout>', '<timeout>', '<timeout>', '<xz>'], translation has ['<xz>']

When compressing, if more than I<timeout> milliseconds (a positive integer) has passed since the previous flush and reading more input would block, all the pending input data is flushed from the encoder and made available in the output stream.  This can be useful if B<xz> is used to compress data that is streamed over a network.  Small I<timeout> values make the data available at the receiving end with a small delay, but large I<timeout> values give better compression ratio.

Vid komprimering, om mer än I<tidsgräns> millisekunder (ett positivt heltal) har gått sedan den föregånde tömningen och en läsning av mer indata skulle blockera töms all väntande indata från kodaren och görs tillgänglig i utdataströmmen. Detta kan vara användbart om B<xz> används för att komprimera data som strömmas över ett nätverk.  Små värden på I<tidsgräns> gör data tillgänglig vid den mottagande änden med en liten fördröjning, men större värden på I<tidsgräns> ger bättre komprimeringsförhållande.

XML/HTML tags mismatch: source has ['<timeout>'], translation has []

This feature is disabled by default.  If this option is specified more than once, the last one takes effect.  The special I<timeout> value of B<0> can be used to explicitly disable this feature.

Denna funktion är avaktiverad som standard. Om denna flagga anges mer än en gång gäller den sista. Dett speciella värdet B<0> på I<tidsgräns> kan användas för att uttryckligen avaktivera denna funktion.

XML/HTML tags mismatch: source has ['<This>', '<xz>', '<xz>'], translation has ['<Denna>', '<xz>', '<xz>']

B<This feature is still experimental.> Currently B<xz> is unsuitable for decompressing the stream in real time due to how B<xz> does buffering.

B<Denna funktion är fortfarande experimentell.> För närvarande är B<xz> olämplig för dekomprimering av strömmen i realtid på grund av hur B<xz> buffrar.

XML/HTML tags mismatch: source has ['<limit>'], translation has []

B<--memlimit-compress=>I<limit>

B<--memlimit-compress=>I<gräns>

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<xz>'], translation has ['<xz>']

If the compression settings exceed the I<limit>, B<xz> will attempt to adjust the settings downwards so that the limit is no longer exceeded and display a notice that automatic adjustment was done.  The adjustments are done in this order: reducing the number of threads, switching to single-threaded mode if even one thread in multi-threaded mode exceeds the I<limit>, and finally reducing the LZMA2 dictionary size.

Om komprimeringsinställnigarna överskrider I<gränsen> kommer B<xz> försöka justera inställningarna neråt så att gränsen inte längre överskrids och visa en notis om att en automatisk justering gjorts. Justeringen görs i denna ordning: reducera antalet trådar, byta till enkeltrådat läge om även en tråd i multitrådat läge överskrider I<gränsen> och slutligen reducera LZMA2-lexikonstorleken.

XML/HTML tags mismatch: source has ['<limit>', '<xz>'], translation has ['<xz>']

If the I<limit> cannot be met even with the adjustments described above, an error is displayed and B<xz> will exit with exit status 1.

Om I<gränsen> inte kan uppfyllas ens med justeringarna som beskrivs ovan visas ett felmeddelande och B<xz> kommer avsluta med slutstatus 1.

XML/HTML tags mismatch: source has ['<limit>'], translation has []

The I<limit> can be specified in multiple ways:

I<Gränsen> kan anges på flera sätt:

XML/HTML tags mismatch: source has ['<MiB>', '<limit>'], translation has ['<MiB>']

The I<limit> can be an absolute value in bytes.  Using an integer suffix like B<MiB> can be useful.  Example: B<--memlimit-compress=80MiB>

I<Gränsen> kan vara ett absolut värde i byte. Att använda ett heltalssuffix som B<MiB> kan vara praktiskt. Exempel: B<--memlimit-compress=80MiB>

XML/HTML tags mismatch: source has ['<limit>'], translation has []

The I<limit> can be specified as a percentage of total physical memory (RAM).  This can be useful especially when setting the B<XZ_DEFAULTS> environment variable in a shell initialization script that is shared between different computers.  That way the limit is automatically bigger on systems with more memory.  Example: B<--memlimit-compress=70%>

I<Gränsen> kan anges som en procentsats av det totala fysiska minnet (RAM). Detta kan vara användbart särskilt när man sätter miljövariabeln B<XZ_DEFAULTS> i ett skalinitieringsskript som delas mellan olika datorer. På det sättet är gränsen automatiskt större på system med mer minne. Exempel: B<--memlimit-compress=70%>

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<max>'], translation has ['<max>']

The I<limit> can be reset back to its default value by setting it to B<0>.  This is currently equivalent to setting the I<limit> to B<max> (no memory usage limit).

I<Gränsen> kan återställas tillbaka till sitt standardvärde genom att sätta den till B<0>. Detta är för närvarande ekvivalent med att sätta I<gränsen> till B<max> (ingen gräns på minnesanvändning).

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<max>', '<xz>'], translation has ['<max>', '<xz>']

For 32-bit B<xz> there is a special case: if the I<limit> would be over B<4020\ MiB>, the I<limit> is set to B<4020\ MiB>.  On MIPS32 B<2000\ MiB> is used instead.  (The values B<0> and B<max> aren't affected by this.  A similar feature doesn't exist for decompression.)  This can be helpful when a 32-bit executable has access to 4\ GiB address space (2 GiB on MIPS32)  while hopefully doing no harm in other situations.

För 32-bitars B<xz> finns det ett specialfall: om I<gränsen> skulle vara över B<4020\ MiB> sätts I<gränsen> till B<4020\ MiB>. På MIPS32 används B<2000\ MiB> istället. (Värdena B<0> och B<max> påverkas inte av detta. En liknande funktion finns inte för dekomprimering.) Detta kan hjälpa till när ett 32-bitarsprogram har tillgång till 4\ GiB adressrymd (2 GiB på MIPS32) förhoppningsvis utan att göra någon skada i andra situationer.

XML/HTML tags mismatch: source has ['<Memory>'], translation has []

See also the section B<Memory usage>.

Se även avsnittet B<Minnesanvändning>.

XML/HTML tags mismatch: source has ['<limit>'], translation has []

B<--memlimit-decompress=>I<limit>

B<--memlimit-decompress=>I<gräns>

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<limit>', '<xz>'], translation has ['<xz>']

Set a memory usage limit for decompression.  This also affects the B<--list> mode.  If the operation is not possible without exceeding the I<limit>, B<xz> will display an error and decompressing the file will fail.  See B<--memlimit-compress=>I<limit> for possible ways to specify the I<limit>.

Sätt en gräns för minnesanvnändningen vid dekomprimering. Detta påverkar även läget B<--list>. Om åtgärden inte är möjlig utan att överskrida I<gränsen> kommer B<xz> visa ett felmeddelande och dekomprimeringen av filen kommer misslyckas. Se B<--memlimit-compress=>I<gräns> för möjliga sätt att ange I<gränsen>.

XML/HTML tags mismatch: source has ['<limit>'], translation has []

B<--memlimit-mt-decompress=>I<limit>

B<--memlimit-mt-decompress=>I<gräns>

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<limit>', '<xz>', '<xz>'], translation has ['<xz>', '<xz>']

Set a memory usage limit for multi-threaded decompression.  This can only affect the number of threads; this will never make B<xz> refuse to decompress a file.  If I<limit> is too low to allow any multi-threading, the I<limit> is ignored and B<xz> will continue in single-threaded mode.  Note that if also B<--memlimit-decompress> is used, it will always apply to both single-threaded and multi-threaded modes, and so the effective I<limit> for multi-threading will never be higher than the limit set with B<--memlimit-decompress>.

Sätt en gräns för minnesanvändningen för multitrådad dekomprimering. Detta kan endast påverka antalet trådar; det kommer aldrig att få B<xz> att vägra att dekomprimera en fil. Om I<gränsen> är för låg för att tillåta någon multitrådning ignoreras I<gränsen> och B<xz> kommer gå vidare i enkeltrådat läge. Observera att om även B<--memlimit-decompress> används kommer det alltid att gälla både enkeltrådat och multitrådat läge, och därmed kommer den gällande I<gränsen> för multitrådning aldrig vara högre än gränsen som sätts med B<--memlimit-decompress>.

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<xz>'], translation has ['<xz>']

In contrast to the other memory usage limit options, B<--memlimit-mt-decompress=>I<limit> has a system-specific default I<limit>.  B<xz --info-memory> can be used to see the current value.

Till skillnad mot de andra flaggorna för gränser för minnesanvändning har B<--memlimit-mt-decompress=>I<gräns> en systemspecifik standardI<gräns>. B<xz --info-memory> kan användas för att se det aktuella värdet.

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<xz>'], translation has ['<xz>']

This option and its default value exist because without any limit the threaded decompressor could end up allocating an insane amount of memory with some input files.  If the default I<limit> is too low on your system, feel free to increase the I<limit> but never set it to a value larger than the amount of usable RAM as with appropriate input files B<xz> will attempt to use that amount of memory even with a low number of threads.  Running out of memory or swapping will not improve decompression performance.

Denna flagga och dess standardvärde finns för att utan någon gräns skulle den trådade dekomprimeraren kunna allokera en vansinnig mängd minne med några indatafiler. Om standardI<gränsen> är för låg på ditt system, öka då gärna I<gränsen> men sätt den aldrig till ett större värde än mängden användbart RAM eftersom att med passande indatafiler kommer B<xz> försöka använda den mängden av minne även med ett lågt antal trådar. Att få slut på minne ller växling kommer inte förbättra dekomprimeringsprestandan.

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<limit>', '<limit>'], translation has []

See B<--memlimit-compress=>I<limit> for possible ways to specify the I<limit>.  Setting I<limit> to B<0> resets the I<limit> to the default system-specific value.

Se B<--memlimit-compress=>I<gräns> för möjliga sätt att ange I<gränsen>. Att sätta I<gräns> till B<0> återställer I<gränsen> till sdet systemspecifika standardvärdet.

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<limit>'], translation has []

B<-M> I<limit>, B<--memlimit=>I<limit>, B<--memory=>I<limit>

B<-M> I<gräns>, B<--memlimit=>I<gräns>, B<--memory=>I<gräns>

XML/HTML tags mismatch: source has ['<limit>', '<limit>', '<limit>'], translation has []

This is equivalent to specifying B<--memlimit-compress=>I<limit> B<--memlimit-decompress=>I<limit> B<--memlimit-mt-decompress=>I<limit>.

Detta är ekvivalent med att ange B<--memlimit-compress=>I<gräns> B<--memlimit-decompress=>I<gräns> B<--memlimit-mt-decompress=>I<gräns>.

XML/HTML tags mismatch: source has ['<threads>', '<threads>'], translation has []

B<-T> I<threads>, B<--threads=>I<threads>

B<-T> I<trådar>, B<--threads=>I<trådar>

XML/HTML tags mismatch: source has ['<threads>', '<threads>', '<xz>'], translation has ['<xz>']

Specify the number of worker threads to use.  Setting I<threads> to a special value B<0> makes B<xz> use up to as many threads as the processor(s) on the system support.  The actual number of threads can be fewer than I<threads> if the input file is not big enough for threading with the given settings or if using more threads would exceed the memory usage limit.

Ange antalet arbetstrådar som skall användas. Att sätta I<trådar> till ett specialvärde B<0> gör att B<xz> använder så många trådar som processorerna på systemet stödjer. Det aktuella antalet trådar kan vara färre än I<trådar> om indatafilen inte är stor nog för trådning med de givna inställningarna eller om användning av fler trådar skulle överkrida gränsen för minnesanvändning.

XML/HTML tags mismatch: source has ['<threads>', '<threads>', '<xz>'], translation has ['<xz>']

The single-threaded and multi-threaded compressors produce different output.  Single-threaded compressor will give the smallest file size but only the output from the multi-threaded compressor can be decompressed using multiple threads.  Setting I<threads> to B<1> will use the single-threaded mode.  Setting I<threads> to any other value, including B<0>, will use the multi-threaded compressor even if the system supports only one hardware thread.  (B<xz> 5.2.x used single-threaded mode in this situation.)

De enkeltrådade och multitrådade komprimerarna producerar olika utdata. Den enkeltrådade komprimeraren kommer ge den minsta filstorleken men endast utdata från den multitrådade komprimeraren kan dekomprimeras med flera trådar. Att sätta I<trådar> till B<1> kommer använda enkeltrådat läge. Att sätta I<trådar> till något annat värde, inklusive B<0>, kommer använda den multitrådade komprimeraren även om systemet endast stödjer en hårdvarutråd.  (B<xz> 5.2.x använde enkeltrådat läge i denna situation.)

XML/HTML tags mismatch: source has ['<threads>', '<xz>', '<xz>'], translation has ['<xz>', '<xz>']

To use multi-threaded mode with only one thread, set I<threads> to B<+1>.  The B<+> prefix has no effect with values other than B<1>.  A memory usage limit can still make B<xz> switch to single-threaded mode unless B<--no-adjust> is used.  Support for the B<+> prefix was added in B<xz> 5.4.0.

För att använda multitrådat läge med endast en tråd, sätt I<trådar> till B<+1>. Prefixet B<+> har ingen påvrekan för andra värden än B<1>. En gräns för minnesanvändning kan fortfarande göra att B<xz> byter till enkeltrådat läge såvida inte B<--no-adjust> används. Stöd för prefixet B<+> lades till i B<xz> 5.4.0.

XML/HTML tags mismatch: source has ['<size>'], translation has ['<storlek>']

Currently the only threading method is to split the input into blocks and compress them independently from each other.  The default block size depends on the compression level and can be overridden with the B<--block-size=>I<size> option.

För närvarande är den enda trådningsmetoden att dela indata i block och komprimera dem oberoende av varandra. Standardstorleken på block beror på komprimeringsnivån och kan åsidosättas med flaggan B<--block-size=>I<storlek>.

XML/HTML tags mismatch: source has ['<size>'], translation has ['<storlek>']

Threaded decompression only works on files that contain multiple blocks with size information in block headers.  All large enough files compressed in multi-threaded mode meet this condition, but files compressed in single-threaded mode don't even if B<--block-size=>I<size> has been used.

Trådad dekomprimering fungerar bara på filer som innehåller flera block med storleksinformation i blockhuvuden. Alla tillräckligt stora filer komprimeras i multitrådat läge för att uppfylla detta villkor, men filer komprimerade i enkeltrådat läge gör det inte ens om B<--block-size=>I<storlek> har använts.

XML/HTML tags mismatch: source has ['<threads>', '<xz>'], translation has ['<xz>']

The default value for I<threads> is B<0>.  In B<xz> 5.4.x and older the default is B<1>.

Standardvärdet på I<trådar> är B<0>. I B<xz> 5.4.x och tidigare är standardvärdet B<1>.

XML/HTML tags mismatch: source has ['<filters>', '<filters>', '<filters>', '<filters>'], translation has ['<filter>', '<filter>', '<filter>', '<filter>']

A custom filter chain can be specified in two different ways.  The options B<--filters=>I<filters> and B<--filters1=>I<filters> \&...\& B<--filters9=>I<filters> allow specifying an entire filter chain in one option using the liblzma filter string syntax.  Alternatively, a filter chain can be specified by using one or more individual filter options in the order they are wanted in the filter chain.  That is, the order of the individual filter options is significant! When decoding raw streams (B<--format=raw>), the filter chain must be specified in the same order as it was specified when compressing.  Any individual filter or preset options specified before the full chain option (B<--filters=>I<filters>)  will be forgotten.  Individual filters specified after the full chain option will reset the filter chain.

En anpassad filterkedja kan anges på två olika sätt. Med flaggorna B<--filters=>I<filter> och B<--filters1=>I<filter> \&…\& B<--filters9=>I<filter> kan man ange en hel filterkedja med en flagga genom att använda syntaxen för liblzma-filtersträngar. Alternativt kan en filterkedja anges genom att använda en eller flera individuella filterflaggor i den ordning de önskas i filterkedjan. Det vill säga, ordningen på de individuella filterflaggorna är signifikant! Vid avkodning av råa strömmar (B<--format=raw>) måste filterkedjan anges i samma ordning som den specificerades vid komprimeringen. Eventuella individuella filter- eller förinstiällningsflaggor angivna före den fullständiga filterkedjeflaggan (B<--filters=>I<filter>) kommer glömmas. Individuella filter som anges efter den flaggan för en full kedja kommer återställa filterkedjan.

XML/HTML tags mismatch: source has ['<options>', '<options>'], translation has ['<flaggor>', '<flaggor>']

Both the full and individual filter options take filter-specific I<options> as a comma-separated list.  Extra commas in I<options> are ignored.  Every option has a default value, so specify those you want to change.

Både den fullständiga och de individuella filterflaggorna tar filterspecifika I<flaggor> som en kommaseparerad lista. Extra komman I<flaggor> ignoreras. Varje flagga har ett standardvärde, så ange dem du vill ändra.

XML/HTML tags mismatch: source has ['<options>', '<xz>'], translation has ['<flaggor>', '<xz>']

To see the whole filter chain and I<options>, use B<xz -vv> (that is, use B<--verbose> twice).  This works also for viewing the filter chain options used by presets.

För att se hela filterkedjan och I<flaggor>, använd B<xz -vv> (det vill säga, använd B<--verbose> två gånger). Detta fungerar även för att se flaggorna för filterkedjor som används av förinställningar.

XML/HTML tags mismatch: source has ['<filters>'], translation has ['<filter>']

B<--filters=>I<filters>

B<--filters=>I<filter>

XML/HTML tags mismatch: source has ['<e>', '<filters>', '<options>'], translation has ['<e>', '<filter>', '<flaggor>']

Specify the full filter chain or a preset in a single option.  Each filter can be separated by spaces or two dashes (B<-->).  I<filters> may need to be quoted on the shell command line so it is parsed as a single option.  To denote I<options>, use B<:> or B<=>.  A preset can be prefixed with a B<-> and followed with zero or more flags.  The only supported flag is B<e> to apply the same options as B<--extreme>.

Ange den fullständiga filterkedan eller en förinställning en en enda flagga. Varje filter kan separeras med blanktecken eller två bindestreck (B<-->). I<filter> kan behöva citeras på skalets kommandorad så att det tolkas som en enda flagga. För att beteckna I<flaggor>, använd B<:> eller B<=>. En förinställning kan föregås med ett B<-> och följas av noll eller flera flaggor. Den enda flaggan som stödjs är B<e> för att tillämpa samma flaggor som B<--extreme>.

XML/HTML tags mismatch: source has ['<filters>', '<filters>'], translation has ['<filter>', '<filter>']

B<--filters1>=I<filters> ... B<--filters9>=I<filters>

B<--filters1>=I<filter> … B<--filters9>=I<filter>

XML/HTML tags mismatch: source has ['<filters>', '<filters>'], translation has ['<filter>', '<filter>']

Display a help message describing how to specify presets and custom filter chains in the B<--filters> and B<--filters1=>I<filters> \&...\& B<--filters9=>I<filters> options, and exit successfully.

Visa ett hjälpmeddelande som beskriver hur man anger förinställningar och anpassade filterkedjor i flaggorna B<--filters> och B<--filters1=>I<filter> \&…\& B<--filters9=>I<filter>, och avsluta rent.

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--lzma1>[B<=>I<options>]

B<--lzma1>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--lzma2>[B<=>I<options>]

B<--lzma2>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

LZMA1 and LZMA2 share the same set of I<options>:

LZMA1 och LZMA2 delar samma uppättning I<flaggor>:

XML/HTML tags mismatch: source has ['<preset>', '<preset>'], translation has ['<preset>']

B<preset=>I<preset>

B<preset=>I<förinställning>

XML/HTML tags mismatch: source has ['<Preset>', '<e>', '<options>', '<options>', '<preset>', '<preset>'], translation has ['<e>', '<flaggor>', '<flaggor>', '<preset>']

Reset all LZMA1 or LZMA2 I<options> to I<preset>.  I<Preset> consist of an integer, which may be followed by single-letter preset modifiers.  The integer can be from B<0> to B<9>, matching the command line options B<-0> \&...\& B<-9>.  The only supported modifier is currently B<e>, which matches B<--extreme>.  If no B<preset> is specified, the default values of LZMA1 or LZMA2 I<options> are taken from the preset B<6>.

Återställ alla LZMA1- eller LZMA2-I<flaggor> till I<förinställning>. I<Förinställning> består av ett heltal, vilket kan följas av enskilda bokstäver som modifierar förinställningen. Heltalet kan vara från B<0> till B<9>, motsvarande kommandoradsflaggorna B<-0> \&…\& B<-9>. Den enda modifierare som stödjs för närvarande är B<e>, vilket motsvarar B<--extreme>. Om ingen B<preset> anges tas standardvärden på LZMA1- eller LZMA2-I<flaggor> från förinställningen B<6>.

XML/HTML tags mismatch: source has ['<dict>', '<size>'], translation has ['<dict>', '<storlek>']

B<dict=>I<size>

B<dict=>I<storlek>

XML/HTML tags mismatch: source has ['<size>', '<size>'], translation has ['<storlek>', '<storlek>']

Dictionary (history buffer)  I<size> indicates how many bytes of the recently processed uncompressed data is kept in memory.  The algorithm tries to find repeating byte sequences (matches) in the uncompressed data, and replace them with references to the data currently in the dictionary.  The bigger the dictionary, the higher is the chance to find a match.  Thus, increasing dictionary I<size> usually improves compression ratio, but a dictionary bigger than the uncompressed file is waste of memory.

Ett lexikons (historiebufferts) I<storlek> indikerar hur många byte med nyligen bearbetad okomprimerad data som hålls i minnet. Algoritmen försöker hitta återkommande bytesekvenser (matchningar) i den okomprimerade datan, och ersätta dem med referenser till datan som för närvarande finns i lexikonet. Ju större lexikon, desto högre är sannolikheten att hitta en matchning. Att öka lexikonets I<storlek> förbättrar alltså vanligen komprimeringsförhållandet, men ett lexikon som är större än den okomprimerade filen är ett slöseri med minne.

XML/HTML tags mismatch: source has ['<size>'], translation has ['<storlek>']

Typical dictionary I<size> is from 64\ KiB to 64\ MiB.  The minimum is 4\ KiB.  The maximum for compression is currently 1.5\ GiB (1536\ MiB).  The decompressor already supports dictionaries up to one byte less than 4\ GiB, which is the maximum for the LZMA1 and LZMA2 stream formats.

En typisk I<storlek> på lexikon är från 64\ KiB till 64\ MiB. Minimum är 4\ KiB. Det maximala för komprimering är för närvarande 1,5\ GiB (1536\ MiB). Dekomprimeraren stödjer redan lexikon upp till en byte mindre än 4\ GiB, vilket är det maximala för strömformaten LZMA1 och LZMA2.

XML/HTML tags mismatch: source has ['<mf>', '<n>', '<n>', '<n>', '<size>', '<size>', '<size>', '<sizes>', '<sizes>'], translation has ['<mf>', '<n>', '<n>', '<n>', '<storlek>', '<storlek>', '<storlekar>', '<storlekar>', '<stort>']

Dictionary I<size> and match finder (I<mf>)  together determine the memory usage of the LZMA1 or LZMA2 encoder.  The same (or bigger) dictionary I<size> is required for decompressing that was used when compressing, thus the memory usage of the decoder is determined by the dictionary size used when compressing.  The B<.xz> headers store the dictionary I<size> either as 2^I<n> or 2^I<n> + 2^(I<n>-1), so these I<sizes> are somewhat preferred for compression.  Other I<sizes> will get rounded up when stored in the B<.xz> headers.

LexikonI<storlek> och matchhittaren (I<mf>) avgör tillsammans minnesanvändningen för LZMA1- eller LZMA2-kodaren. Ett lika I<stort> (eller större) lexikon behövs för dekomprimering som det som användes vid komprimeringen, minnesanvändningen för avkodaren avgörs alltså av lexikonstorleken vid komprimering. Huvudena i B<.xz> innehåller lexikonets I<storlek> antingen som 2^I<n> eller 2^I<n> + 2^(I<n>-1), så dessa I<storlekar> är lite att föredra för komprimering. Andra I<storlekar> kommer avrundas uppåt när de lagras i huvuden i B<.xz>.

XML/HTML tags mismatch: source has ['<lc>', '<lc>'], translation has ['<lc>', '<lk>']

B<lc=>I<lc>

B<lc=>I<lk>

XML/HTML tags mismatch: source has ['<lc>', '<lp>'], translation has ['<lk>', '<lp>']

Specify the number of literal context bits.  The minimum is 0 and the maximum is 4; the default is 3.  In addition, the sum of I<lc> and I<lp> must not exceed 4.

Ange antalet literala kontextbitar. Minimum är 0 och maximum är 4; standardvärdet är 3. Dessutom får inte summan av I<lk> och I<lp> överskrida 4.

XML/HTML tags mismatch: source has ['<lc>', '<lc>'], translation has ['<lk>', '<lk>']

The literal coding makes an assumption that the highest I<lc> bits of the previous uncompressed byte correlate with the next byte.  For example, in typical English text, an upper-case letter is often followed by a lower-case letter, and a lower-case letter is usually followed by another lower-case letter.  In the US-ASCII character set, the highest three bits are 010 for upper-case letters and 011 for lower-case letters.  When I<lc> is at least 3, the literal coding can take advantage of this property in the uncompressed data.

Den literala kodningen gör antagandet att de högsta I<lk> bitarna av den föregående okomprimerade byten korrelerar med nästa byte. Till exempel, i typisk engelsk text följs ofta en versal bokstav av en gemen bokstav, och en gemen bokstav följs vanligen av en annan gemen bokstav. I teckenuppsättningen US-ASCII är de högsta tre bitarna 010 för versala bokstäver och 011 för gemena bokstäver. När I<lk> är åtminstone 3 kan den literala kodningen dra nytta av denna egenskap i den okomprimerade datan.

XML/HTML tags mismatch: source has ['<mf>', '<mf>'], translation has ['<mf>', '<ms>']

B<mf=>I<mf>

B<mf=>I<ms>

XML/HTML tags mismatch: source has ['<bt4>', '<hc3>', '<hc4>', '<preset>'], translation has ['<bt4>', '<hc3>', '<hc4>']

Match finder has a major effect on encoder speed, memory usage, and compression ratio.  Usually Hash Chain match finders are faster than Binary Tree match finders.  The default depends on the I<preset>: 0 uses B<hc3>, 1\(en3 use B<hc4>, and the rest use B<bt4>.

Matchsökaren har en stor poverkan på kodarens hastighet, minnesanvändning och komprimeringsförhållande. Vanligen är Hashkedje-matchsökare snabbare än Binärträdsmatchsökare. Standardvärdet beror på I<föinställningen>: 0 använder B<hc3>, 1\(en3 använder B<hc4>, och resten använder B<bt4>.

XML/HTML tags mismatch: source has ['<dict>', '<dict>', '<lt>'], translation has ['<dict>', '<dict>']

I<dict> * 7.5 (if I<dict> E<lt>= 16 MiB);

I<dict> · 7.5 (om I<dict> ≤ 16 MiB);

XML/HTML tags mismatch: source has ['<dict>', '<dict>', '<lt>'], translation has ['<dict>', '<dict>']

I<dict> * 7.5 (if I<dict> E<lt>= 32 MiB);

I<dict> · 7,5 (om I<dict> ≤ 32 MiB);

XML/HTML tags mismatch: source has ['<dict>', '<dict>', '<lt>'], translation has ['<dict>', '<dict>']

I<dict> * 11.5 (if I<dict> E<lt>= 16 MiB);

I<dict> · 11,5 (om I<dict> ≤ 16 MiB);

XML/HTML tags mismatch: source has ['<dict>', '<dict>', '<lt>'], translation has ['<dict>', '<dict>']

I<dict> * 11.5 (if I<dict> E<lt>= 32 MiB);

I<dict> · 11,5 (om I<dict> ≤ 32 MiB);

XML/HTML tags mismatch: source has ['<mode>', '<mode>'], translation has ['<mode>']

B<mode=>I<mode>

B<mode=>I<läge>

XML/HTML tags mismatch: source has ['<fast>', '<fast>', '<mode>', '<modes>', '<normal>', '<normal>', '<presets>', '<presets>'], translation has ['<fast>', '<fast>', '<normal>', '<normal>']

Compression I<mode> specifies the method to analyze the data produced by the match finder.  Supported I<modes> are B<fast> and B<normal>.  The default is B<fast> for I<presets> 0\(en3 and B<normal> for I<presets> 4\(en9.

KomprimeringsI<läget> anger metoden som används för att analysera data skapade av matchsökaren. De I<lägen> som stödjs är B<fast> och B<normal>. Standardvärdet är B<fast> för I<förinställningarna> 0\(en3 och B<normal> för I<förinställningarna> 4\(en9

XML/HTML tags mismatch: source has ['<fast>', '<normal>', '<presets>'], translation has ['<fast>', '<normal>']

Usually B<fast> is used with Hash Chain match finders and B<normal> with Binary Tree match finders.  This is also what the I<presets> do.

Vanligen används B<fast> med Hashkedjematchsökare och B<normal> med Binärträdsmatchsökare. Detta är även vad I<förinställningarna> gör.

XML/HTML tags mismatch: source has ['<nice>', '<nice>'], translation has ['<lagom>', '<nice>']

B<nice=>I<nice>

B<nice=>I<lagom>

XML/HTML tags mismatch: source has ['<nice>'], translation has ['<lagom>']

Specify what is considered to be a nice length for a match.  Once a match of at least I<nice> bytes is found, the algorithm stops looking for possibly better matches.

Ange vad som anses vara en lagom längt på en matchning. När en matchning på åtminstone I<lagom> byte hittats slutar algoritmen söka efter möjliga bättre matchningar.

XML/HTML tags mismatch: source has ['<Nice>', '<preset>'], translation has ['<Lagom>']

I<Nice> can be 2\(en273 bytes.  Higher values tend to give better compression ratio at the expense of speed.  The default depends on the I<preset>.

I<Lagom> kan vara 2\(en273 byte. Högre värden tenderar att ge bättre komprimeringsförhållande på bekostnad av tid. Standardvärdet beror på I<förinställningen>.

XML/HTML tags mismatch: source has ['<depth>', '<depth>'], translation has ['<depth>', '<djup>']

B<depth=>I<depth>

B<depth=>I<djup>

XML/HTML tags mismatch: source has ['<depth>', '<mf>', '<nice>'], translation has ['<djup>', '<mf>', '<nice>']

Specify the maximum search depth in the match finder.  The default is the special value of 0, which makes the compressor determine a reasonable I<depth> from I<mf> and I<nice>.

Ange det maximala sökdjupet i matchsökaren. Standardvärdet är specialvärdet 0, vilket får komprimeraren att avgöra ett lämpligt I<djup> från I<mf> och I<nice>.

XML/HTML tags mismatch: source has ['<depth>', '<depth>', '<depth>'], translation has ['<djup>', '<djup>', '<djup>']

Reasonable I<depth> for Hash Chains is 4\(en100 and 16\(en1000 for Binary Trees.  Using very high values for I<depth> can make the encoder extremely slow with some files.  Avoid setting the I<depth> over 1000 unless you are prepared to interrupt the compression in case it is taking far too long.

Lämpligt I<djup> för Hashkedjor är 4\(en100 och 16\(en1000 för Binärträd. Att använda väldigt höga värden på I<djup> kan göra kodaren extremt långsam för vissa filer. Undvik att sätta I<djup> över 1000 såvida du inte är beredd att avbryta komprimeringen om den tar för lång tid.

XML/HTML tags mismatch: source has ['<lc>', '<lp>', '<pb>', '<size>'], translation has ['<lc>', '<lp>', '<pb>', '<storlek>']

When decoding raw streams (B<--format=raw>), LZMA2 needs only the dictionary I<size>.  LZMA1 needs also I<lc>, I<lp>, and I<pb>.

Vid avkodning av råa strömmar (B<--format=raw>) behöver LZMA2 endast lexikonets I<storlek>. LZMA1 behöver även I<lc>, I<lp> och I<pb>.

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--x86>[B<=>I<options>]

B<--x86>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--arm>[B<=>I<options>]

B<--arm>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--armthumb>[B<=>I<options>]

B<--armthumb>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--arm64>[B<=>I<options>]

B<--arm64>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--powerpc>[B<=>I<options>]

B<--powerpc>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--ia64>[B<=>I<options>]

B<--ia64>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--sparc>[B<=>I<options>]

B<--sparc>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--riscv>[B<=>I<options>]

B<--riscv>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

All BCJ filters support the same I<options>:

Alla BCJ-filter stödjer samma I<flaggor>:

XML/HTML tags mismatch: source has ['<offset>', '<start>'], translation has ['<start>']

B<start=>I<offset>

B<start=>I<avstånd>

XML/HTML tags mismatch: source has ['<offset>', '<offset>', '<offset>'], translation has []

Specify the start I<offset> that is used when converting between relative and absolute addresses.  The I<offset> must be a multiple of the alignment of the filter (see the table above).  The default is zero.  In practice, the default is good; specifying a custom I<offset> is almost never useful.

Ange startI<avståndet> som används vid konvertering mellan relativa och absoluta adresser. I<Avståndet> måste vara en multipel av filtrets justering (se tabellen ovan). Standardvärdet är noll. I praktiken är standardvärdet bra; det är nästan aldrig användbart att ange ett anpassat I<avstånd>.

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

B<--delta>[B<=>I<options>]

B<--delta>[B<=>I<flaggor>]

XML/HTML tags mismatch: source has ['<options>'], translation has ['<flaggor>']

Supported I<options>:

Stödda I<flaggor>:

XML/HTML tags mismatch: source has ['<dist>', '<distance>'], translation has ['<dist>']

B<dist=>I<distance>

B<dist=>I<avstånd>

XML/HTML tags mismatch: source has ['<distance>', '<distance>'], translation has []

Specify the I<distance> of the delta calculation in bytes.  I<distance> must be 1\(en256.  The default is 1.

Ange I<avståndet> för deltaberäkningen i byte. I<Avstånd> måste varea 1\(en256. Standardvärdet är 1.

XML/HTML tags mismatch: source has ['<ROBOT>', '<xz>', '<xz>'], translation has ['<xz>', '<xz>']

Print messages in a machine-parsable format.  This is intended to ease writing frontends that want to use B<xz> instead of liblzma, which may be the case with various scripts.  The output with this option enabled is meant to be stable across B<xz> releases.  See the section B<ROBOT MODE> for details.

Skriv meddelanden i maskinläsbart form. Detta är avsett att förenkla att skriva framändar som vill använda B<xz> istället för liblzma, vilken kan vara fallet i olika skript. Utdatan med denna flagga aktiverad är avsedd att vara stabil mellan utgåvor av B<xz>. Se avsnitett B<ROBOTLÄGE> för detaljer.

XML/HTML tags mismatch: source has ['<Since>', '<xz>'], translation has ['<xz>']

I<Since> B<xz> I<5.1.2alpha:>

I<Från> B<xz> I<5.1.2alpha:>

XML/HTML tags mismatch: source has ['<E>', '<E>', '<filter>', '<lt>', '<lt>', '<option>', '<option>', '<value>', '<value>'], translation has ['<E>', '<E>', '<filter>', '<flagga>', '<flagga>', '<lt>', '<lt>']

I<filter>B<:>I<option>B<=E<lt>>I<value>B<E<gt>,>I<option>B<=E<lt>>I<value>B<E<gt>>...

I<filter>B<:>I<flagga>B<=E<lt>>I<värde>B<E<gt>,>I<flagga>B<=E<lt>>I<värde>B<E<gt>>…

XML/HTML tags mismatch: source has ['<option>'], translation has ['<flagga>']

I<option>

I<flagga>

XML/HTML tags mismatch: source has ['<value>'], translation has []

I<value>

I<värde>

XML/HTML tags mismatch: source has ['<E>', '<E>', '<E>', '<gt>', '<max>', '<min>', '<value>', '<value>'], translation has ['<E>', '<E>', '<E>', '<gt>', '<max>', '<min>']

Numeric I<value> ranges appear as B<E<lt>>I<min>B<->I<max>B<E<gt>>.  String I<value> choices are shown within B<E<lt> E<gt>> and separated by a B<|> character.

Numeriska I<värde>intervall ser ut som B<E<lt>>I<min>B<->I<max>B<E<gt>>. SträngI<värdes> val visas inom B<E<lt> E<gt>> och separerade med ett B<|>-tecken.

XML/HTML tags mismatch: source has ['<Warning>', '<xz>', '<xz>'], translation has ['<Varning>', '<xz>', '<xz>']

B<Warning:> By setting these environment variables, one is effectively modifying programs and scripts that run B<xz>.  Most of the time it is safe to set memory usage limits, number of threads, and compression options via the environment variables.  However, some options can break scripts.  An obvious example is B<--help> which makes B<xz> show the help text instead of compressing or decompressing a file.  More subtle examples are B<--quiet> and B<--verbose>.  In many cases it works well to enable the progress indicator using B<--verbose>, but in some situations the extra messages create problems.  The verbosity level also affects the behavior of B<--list>.

B<Varning:> genom att sätta dessa miljövariabler ändrar man i praktiken program och skript som kör B<xz>. för det mesta är set säkert att sätta begränsningar på minnesanvändning, antal trådar och komprimeringsflaggor via miljövariablerna. Några flaggor kan dock göra att skript går sönder. Ett uppenbart exempel är B<--help> vilket gör att B<xz> visar en hjälptext istället för att komprimera eller dekomprimera en fil. Mer subtila exempel är B<--quiet> och B<--verbose>. I många fall fungerar det bra att aktivera en förloppsindikator med B<--verbose>, men i några fall skapar de extra meddelandena problem. Utförlighetsnivån påverkar även beteendet hos B<--list>.

XML/HTML tags mismatch: source has ['<check>', '<crc32>', '<none>'], translation has ['<crc32>', '<kontroll>', '<none>']

Embedded B<.xz> decompressor implementations like XZ Embedded don't necessarily support files created with integrity I<check> types other than B<none> and B<crc32>.  Since the default is B<--check=crc64>, you must use B<--check=none> or B<--check=crc32> when creating files for embedded systems.

Inbäddade implementationer av B<.xz>-dekomprimerare som XZ Embedded stödjer inte nödvändigtvis filer som skapas med andra typer av integritetsI<kontroll> än B<none> och B<crc32>. Eftersom standardvärdet är B<--check=crc64> måste man använda B<--check=none> eller B<--check=crc32> när filer skapas för inbäddade system.

XML/HTML tags mismatch: source has ['<check>', '<check>'], translation has ['<kontrollen>', '<kontroller>']

Outside embedded systems, all B<.xz> format decompressors support all the I<check> types, or at least are able to decompress the file without verifying the integrity check if the particular I<check> is not supported.

Utanför inbäddade system stödjer alla dekomprimerare av B<.xz>-format alla typerna av I<kontroller>, eller åtminstone kan de dekomprimera filern utan att verifiera integritetskontrollen om den specifika I<kontrollen> inte stödjs.

XML/HTML tags mismatch: source has ['<foo>', '<foo>', '<foo>'], translation has ['<apa>', '<apa>', '<apa>']

Compress the file I<foo> into I<foo.xz> using the default compression level (B<-6>), and remove I<foo> if compression is successful:

Komprimera filen I<apa> till I<apa.xz> med standardkomprimeringsnivån (B<-6>), och ta bort I<apa> om komprimeringen lyckas:

XML/HTML tags mismatch: source has ['<bar>', '<bar>', '<bar>'], translation has ['<bepa>', '<bepa>', '<bepa>']

Decompress I<bar.xz> into I<bar> and don't remove I<bar.xz> even if decompression is successful:

Dekomprimera I<bepa.xz> till I<bepa> och ta inte bort I<bepa.xz> även om dekomprimeringen lyckas:

XML/HTML tags mismatch: source has ['<baz>'], translation has ['<cepa>']

Create I<baz.tar.xz> with the preset B<-4e> (B<-4 --extreme>), which is slower than the default B<-6>, but needs less memory for compression and decompression (48\ MiB and 5\ MiB, respectively):

Skapa I<cepa.tar.xz> med förinställningen B<-4e> (B<-4 --extreme>), vilket är långsammare än standardvärdet B<-6>, men behöver mindre minne till komprimering och dekomprimering (48\ MiB respektive 5\ MiB):

XML/HTML tags mismatch: source has ['<file>', '<option>', '<xzdec>'], translation has ['<fil>', '<flagga>', '<xzdec>']

B<xzdec> [I<option...>] [I<file...>]

B<xzdec> [I<flagga…>] [I<fil…>]

XML/HTML tags mismatch: source has ['<file>', '<lzmadec>', '<option>'], translation has ['<fil>', '<flagga>', '<lzmadec>']

B<lzmadec> [I<option...>] [I<file...>]

B<lzmadec> [I<flagga…>] [I<fil…>]

XML/HTML tags mismatch: source has ['<file>', '<lzmainfo>'], translation has ['<fil>', '<lzmainfo>']

B<lzmainfo> [B<--help>] [B<--version>] [I<file...>]

B<lzmainfo> [B<--help>] [B<--version>] [I<fil…>]

XML/HTML tags mismatch: source has ['<file>', '<file>', '<files>', '<lzmainfo>'], translation has ['<fil>', '<filen>', '<filer>', '<lzmainfo>']

B<lzmainfo> shows information stored in the B<.lzma> file header.  It reads the first 13 bytes from the specified I<file>, decodes the header, and prints it to standard output in human readable format.  If no I<files> are given or I<file> is B<->, standard input is read.

B<lzmainfo> visar information som finns lagrad i filhuvudet i B<.lzma>. Den läser de första 13 byten från den angivna I<filen>, avkodar huvudet, och skriver ut det till standard ut i mänskligt läsbart format. Om inga I<filer> anges eller I<fil> är B<->, läses standard in.

XML/HTML tags mismatch: source has ['<file1>', '<file2>', '<option>', '<xzcmp>'], translation has ['<fil1>', '<fil2>', '<flagga>', '<xzcmp>']

B<xzcmp> [I<option...>] I<file1> [I<file2>]

B<xzcmp> [I<flagga…>] I<fil1> [I<fil2>]

XML/HTML tags mismatch: source has ['<bzip2>', '<file1>', '<file1>', '<file2>', '<file2>', '<gzip>', '<lz4>', '<lzop>', '<xz>', '<xz>', '<zstd>'], translation has ['<bzip2>', '<fil1>', '<fil1>', '<fil2>', '<fil2>', '<gzip>', '<lz4>', '<lzop>', '<xz>', '<xz>', '<zstd>']

If both I<file1> and I<file2> are specified, they can be uncompressed files or files in formats that B<xz>(1), B<gzip>(1), B<bzip2>(1), B<lzop>(1), B<zstd>(1), or B<lz4>(1)  can decompress.  The required decompression commands are determined from the filename suffixes of I<file1> and I<file2>.  A file with an unknown suffix is assumed to be either uncompressed or in a format that B<xz>(1)  can decompress.

Om både I<fil1> och I<fil2> anges kan de vara okomprimerade filer eller filer i format som B<xz>(1), B<gzip>(1), B<bzip2>(1), B<lzop>(1), B<zstd>(1) eller B<lz4>(1) kan dekomprimera. De nödvändiga dekomprimeringskommandona avgörs från filnamnsändelsen på I<fil1> och I<fil2>. En fil med en okänd ändelse antas antingen vara okomprimerad eller i ett format som B<xz>(1) kan dekomprimera.

XML/HTML tags mismatch: source has ['<file1>', '<file1>', '<file2>'], translation has ['<fil1>', '<fil1>', '<fil2>']

If only one filename is provided, I<file1> must have a suffix of a supported compression format and the name for I<file2> is assumed to be I<file1> with the compression format suffix removed.

Om endast ett filnamn anges måste I<fil1> ha en ändelse med ett av de stödda komprimeringsformaten och namnet på I<fil2> antas vara I<fil1> med komprimeringsformatsändelsen borttagen.

XML/HTML tags mismatch: source has ['<file>', '<option>', '<xzgrep>'], translation has ['<fil>', '<flagga>', '<xzgrep>']

B<xzgrep> [I<option...>] [I<pattern_list>] [I<file...>]

B<xzgrep> [I<flagga…>] [I<mönsterlista>] [I<fil…>]

XML/HTML tags mismatch: source has ['<bzip2>', '<file>', '<files>', '<grep>', '<gzip>', '<lz4>', '<lzop>', '<xz>', '<xzgrep>', '<zstd>'], translation has ['<bzip2>', '<fil>', '<filerna>', '<grep>', '<gzip>', '<lz4>', '<lzop>', '<xz>', '<xzgrep>', '<zstd>']

B<xzgrep> invokes B<grep>(1)  on uncompressed contents of files.  The formats of the I<files> are determined from the filename suffixes.  Any I<file> with a suffix supported by B<xz>(1), B<gzip>(1), B<bzip2>(1), B<lzop>(1), B<zstd>(1), or B<lz4>(1)  will be decompressed; all other files are assumed to be uncompressed.

B<xzgrep> anropar B<grep>(1) på det okomprimerade innehållet i filerna. Formaten på I<filerna> bestäms utgående från filnamnsändelsen.  En I<fil> med en ändelse som stödjs av B<xz>(1), B<gzip>(1), B<bzip2>(1), B<lzop>(1), B<zstd>(1) eller B<lz4>(1) kommer att dekomprimeras; alla andra filer antas vara okomprimerade.

XML/HTML tags mismatch: source has ['<file>', '<files>', '<xz>'], translation has ['<fil>', '<filer>', '<xz>']

If no I<files> are specified or I<file> is B<-> then standard input is read.  When reading from standard input, only files supported by B<xz>(1)  are decompressed.  Other files are assumed to be in uncompressed form already.

Om inga I<filer> anges eller om I<fil> är B<-> lästes standard in. När standard in läses är de enda filerna som dekomprimeras de som stödjs av B<xz>(1).  Andra filer antas redan vara i okomprimerad form.

XML/HTML tags mismatch: source has ['<grep>', '<options>'], translation has ['<flaggor>', '<grep>']

Most I<options> of B<grep>(1)  are supported.  However, the following options are not supported:

De flesta I<flaggor> till B<grep>(1) stödjs. Dock stödjs inte följande flaggor:

XML/HTML tags mismatch: source has ['<action>'], translation has []

B<-d>, B<--directories=>I<action>

B<-d>, B<--directories=>I<åtgärd>

XML/HTML tags mismatch: source has ['<file>'], translation has ['<fil>']

B<--exclude-from=>I<file>

B<--exclude-from=>I<fil>

XML/HTML tags mismatch: source has ['<file>', '<xzless>'], translation has ['<fil>', '<xzless>']

B<xzless> [I<file>...]

B<xzless> [I<fil>…]

XML/HTML tags mismatch: source has ['<file>', '<lzless>'], translation has ['<fil>', '<lzless>']

B<lzless> [I<file>...] (DEPRECATED)

B<lzless> [I<fil>…] (FÖRÅLDRAT)

XML/HTML tags mismatch: source has ['<files>', '<xz>', '<xzless>', '<xzless>'], translation has ['<filer>', '<xz>', '<xzless>', '<xzless>']

B<xzless> is a filter that displays text from compressed files to a terminal.  Files supported by B<xz>(1)  are decompressed; other files are assumed to be in uncompressed form already.  If no I<files> are given, B<xzless> reads from standard input.

B<xzless> är ett filter som visar text från komprimerade filer i en terminal. Filer som stödjs av B<xz>(1) dekomprimeras; andra filer antas redan vara i okomprimerad form.  Om inga I<filer> ges läser B<xzless> från standard in.

XML/HTML tags mismatch: source has ['<file>', '<xzmore>'], translation has ['<fil>', '<xzmore>']

B<xzmore> [I<file>...]

B<xzmore> [I<fil>…]

XML/HTML tags mismatch: source has ['<file>', '<lzmore>'], translation has ['<fil>', '<lzmore>']

B<lzmore> [I<file>...] (DEPRECATED)

B<lzmore> [I<fil>…] (FÖRÅLDRAT)

XML/HTML tags mismatch: source has ['<files>', '<more>', '<more>', '<xz>', '<xzmore>', '<xzmore>'], translation has ['<filer>', '<more>', '<more>', '<xz>', '<xzmore>', '<xzmore>']

B<xzmore> displays text from compressed files to a terminal using B<more>(1).  Files supported by B<xz>(1)  are decompressed; other files are assumed to be in uncompressed form already.  If no I<files> are given, B<xzmore> reads from standard input.  See the B<more>(1)  manual for the keyboard commands.

B<xzmore> visar text från komprimerade filer i en terminal med användning av B<more>(1). Filer som stödjs av B<xz>(1) dekomprimeras; andra filer antas redan vara i okomprimerad form. Om inga I<filer> ges läser B<xzmore> från standard in. Se manualen för B<more>(1) för tangentbordskommandona.