Untar, ungz, gz, tar - come ricordi tutte le opzioni utili?

Sono abbastanza sicuro di non essere l'unico con il seguente problema: ogni volta che devo decomprimere un file in * nix non riesco a ricordare tutti gli switch e finisco per cercarlo su Google, il che è sorprendente considerando quanto spesso devo Fai questo.

Hai un cheat sheet a compressione buona? O che ne dici di un mnemonico per tutti quei cattivi interruttori nel catrame?

Sto trasformando questo articolo in un wiki in modo da poter creare un bel cheat sheet qui.

Oh, e sulle pagine man: c'è una cosa per cui non sono utili, è capire come decomprimere un file.

O che ne dici di usare la shell con funzionalità di completamento avanzate (come zsh o nuove versioni di bash) che completeranno le opzioni per te, con un aiuto completo? :))

Per quanto riguarda tar: basta guardare la tastiera "qwerty". Ci sono lettere "zxcvf" una accanto all'altra. È necessario "tar czvf file.tar.gz files" o "tar xzvf file.tar.gz".

Riepilogo delle opzioni di catrame

Siete invitati a modificarlo per aggiungere ulteriori interruttori esoterici, ma ecco le basi:

• x - estrae i file
• c - crea un archivio
• t - elenca i file
• v - verbose (elenca i file mentre li elabora)
• j - usa la compressione bz2
• z - usa la compressione gz
• f - legge o scrive file su disco

Esempi

Decomprimi un file tar.gz: tar zxf tarball.tar.gz

Decomprimi un file tar.bz2: tar jxf tarball.tar.bz2

Crea un file tar.gz: tar zcvf tarvall.tar.gz mydir / *

C'è un piccolo script Perl chiamato "unp".

unp filename.tar.gz

... ed estrae tutto. Funziona con qualsiasi file compresso purché si disponga dei file binari corretti. E ti dimentichi solo della sintassi o di quella merda. Controlla i repository della tua distribuzione Linux. Dovrebbe essere lì (almeno su Arch, Debian e Ubuntu).

Davvero con un uso frequente faccio la differenza tra estrarre (x) dati e comprimere (c) dati:

Estrarre:

tar xzf data.tgz

Per comprimere:

tar czf data.tgz

Inoltre puoi aggiungere anche due funzioni al tuo .bashrc:

function extract () {     
        if ($# -ne 1); then
                echo "Usage: $0  `<compressed archive>"`
                exit 1
        fi
        tar xzf $1
}

function compress () {
        if ($# -ne 2); then
                echo "Usage: $0 `<compressed archive> <files|directories>"`
                exit 1
        fi
        tar czf $1 $2
}

C'è un'altra bella funzione di estrazione, che rileva l'estensione del file compresso e fa il lavoro per te:

extract () {
   if [ -f $1 ] ; then
       case $1 in
           *.tar.bz2)   tar xvjf $1    ;;
           *.tar.gz)    tar xvzf $1    ;;
           *.bz2)       bunzip2 $1     ;;
           *.rar)       unrar x $1       ;;
           *.gz)        gunzip $1      ;;
           *.tar)       tar xvf $1     ;;
           *.tbz2)      tar xvjf $1    ;;
           *.tgz)       tar xvzf $1    ;;
           *.zip)       unzip $1       ;;
           *.Z)         uncompress $1  ;;
           *.7z)        7z x $1        ;;
           *)           echo "don't know how to extract '$1'..." ;;
       esac
   else
       echo "'$1' is not a valid file!"
   fi
 }

Basta digitare tar --helpe c'è il tuo cheatsheet.

Se hai problemi a ricordare le opzioni tar, prova a usare le pipe:

• zcat file.tar.gz | tar xvf -
• bzcat file.tar.bz2 | tar xvf -

Sostituisci tar xvcon tar tvper visualizzare solo i contenuti del tarball.

Personalmente, utilizzo i seguenti mnemonici:

• t, x, o c rispettivamente per "tabulazione", "sottrazione" o "creazione".
• v per elencare tutti i file.
• z, j o ​​niente per tar.gz, tar.bz2 o semplicemente .tar, rispettivamente.
• f per dare un nome file, rispetto al valore predefinito di usare stdin / stdout o un dispositivo a nastro.

Anche se "j" e "bzip2" sembrano non avere nulla a che fare l'uno con l'altro, trovo facile ricordare questa eccezione.

Inoltre, trovo divertente che Google abbia sostituito "man tar".

L'uomo è tuo amico.

man tar

Le tre operazioni più utilizzate :

--create -c

Crea un nuovo archivio tar.

--list -t

Elencare i contenuti di un archivio.

--extract -x

Estrarre uno o più membri da un archivio.

Le cinque operazioni avanzate di tar :

--append -r

Aggiungi nuove voci a un archivio già esistente.

--update -u

Aggiungi copie più recenti dei membri dell'archivio alla fine di un archivio, se presenti.

--concatenate --catenate -A

Aggiungi uno o più archivi preesistenti alla fine di un altro archivio.

--delete

Elimina elementi da un archivio (non funziona sui nastri).

--compare --diff -d

Confronta i membri dell'archivio con le loro controparti nel file system.

Durante la digitazione leggo sempre i comandi nella mia mente

comprime file zip dettagliato

tar cvzf FILE

estrarre il file zip dettagliato FILE

tar xvzf FILE

Faccio quanto segue

Per creare un tar:

tar czvf foo.tar.gz <files to be included>

Per decomprimere:

tar zxvf foo.tar.gz

Questi dovrebbero essere gli switch principali di cui devi preoccuparti:

c - create
z - compress/uncompress
x - extracte
v - verbose
f - file

Puoi fare alcune cose più fantasiose come tar e untar inline mentre stai provando a spostare i file tra le directory in questo modo:

tar cf - <files to be copied> | (cd <target directory>; tar xvf - )

Il 90% delle volte lo uso

tar -xvf file.*  

x: extract
v: be verbose (opzionale)
f: file di input (tar, gz, bzip2, ecc ...)

Facile, eh? :)
Usa Fileroller o Ark se non sei in una console.

Sto usando uno script Perl chiamato aunpack, parte del progetto atool , ormai da molti anni. Quindi esegui semplicemente: aunpack foo.{zip/tar.gz/tar.bz2}e fa la cosa giusta in base all'estensione del file.

L'altro vantaggio aunpackè che non inquinerà la directory corrente con molti file. Supponiamo che ci siano 20 file foo.zipche non si trovano in una sottodirectory. Invece di sputare questi file nella directory corrente, aunpackcreerà una foosottodirectory e inserirà tutti i file.

Tutto ciò che serve è tar x(estrai da stdin), tar c(tar a stdout), gzip -c(gzip da stdin a stdout; -1a -9per i livelli di compressione; lo stesso vale per bzip2) e gunzip -c(gunzip da stdin a stdout) - tutto il resto è pipe.

Per tar e gzip:

$ tar c * | gzip -c > out.tar.gz

Per decomprimere e decomprimere

$ gunzip -c < out.tar.gz | tar x

Se vuoi barre di avanzamento dolci, usa pv che è simile a cat ma mostra le barre di avanzamento:

$ tar c * | bzip2 -c | pv > out.tar.gz
 22.6MiB 0:00:03 [3.64MiB/s] [  <=>                           ]
$ pv in.tar.gz | bunzip2 -c | tar x
   80MiB 0:00:00 [  58MiB/s] [===============================>] 100%

Penso che sia facile pensare a quello che vuoi e non solo ad alcune lettere.

Per illustrare, userò un esempio di come estrarre file.tar.gz:

Dato che è un file tar, dovresti usare il programma tar. Quindi sono le opzioni:

1. x dal momento che vuoi e x tratto.
2. z se il file termina con .gz. (gz è dopo tar nel nome del file) Questa opzione comprime l'archivio.
3. f per il file seguito dal nome dell'archivio.

Questo è dimostrato nell'esempio seguente:

tar xzf file.tar.gz

Il modo in cui ricordo è che è sempre "tar XXvf", dove si trovano le due X.

• x per e X tratto o c per C reate e,
• o z = gzip, j = bzip2 (gzip è più comune, quindi di solito è z, per qualsiasi motivo il j = bzip2 è semplicemente bloccato nella mia testa).

Di tanto in tanto ti imbatti in file compressi ma non tarati in cui aggiungi un a qualunque sia il tipo di compressione. ad es. g un zip o b un zip2.

Semmai, dimentico il 2 e talvolta scrivo "bzip".

puoi anche creare un alias. aggiungi queste due righe al tuo ~/.bash_aliasesfile:

alias untar="tar xvf"
alias dotar="tar cvf"

è quindi possibile utilizzare untar foo.tar.gzper estrarre e dotar foo.barcomprimere. puoi usare altri alias facili da ricordare.

C rea z Z ip a F ilename

tar -czf myfile.tar.gz myfile.sql

e X del tratto Z IP con F ilename

tar -xzf myfile.tar.gz