Comment puis-je décompresser un fichier .tar.gz en une seule étape (en utilisant 7-Zip) ?

Pas vraiment. Un fichier .tar.gz ou .tgz est en fait deux formats : .tar est l'archive, et .gz est la compression. La première étape consiste donc à décompresser, et la seconde à extraire l'archive.

Pour faire tout cela en une seule étape, vous avez besoin du programme tar. Cygwin (http://www.cygwin.com/) comprend cela.

tar xzvf foobaz.tar.gz

; x = eXtract 
; z = filter through gZip
; v = be Verbose (show activity)
; f = filename

Vous pouvez également le faire “en une seule étape” en ouvrant le fichier dans l'interface graphique 7-zip : Ouvrez le fichier .tar.gz, double-cliquez sur le fichier .tar inclus, puis extrayez ces fichiers à l'emplacement de votre choix.

Il y a un long fil de discussion ici de personnes demandant / votant pour une manipulation en une étape des fichiers tgz et bz2. L'absence d'action jusqu'à présent indique que cela ne se produira pas tant que quelqu'un n'aura pas fait un pas et contribué de manière significative (code, argent, quelque chose).

C'est une vieille question, mais j'ai eu du mal à la poser aujourd'hui, alors voici mon 2c. L'outil en ligne de commande 7zip “7z.exe” (j'ai installé la v9.22) peut écrire sur stdout et lire sur stdin, vous pouvez donc vous passer du fichier tar intermédiaire en utilisant un tube :

7z x "somename.tar.gz" -so | 7z x -aoa -si -ttar -o"somename"

Où :

x = Extract with full paths command
-so = write to stdout switch
-si = read from stdin switch
-aoa = Overwrite all existing files without prompt.
-ttar = Treat the stdin byte stream as a TAR file
-o = output directory

Voir le fichier d'aide (7-zip.chm) dans le répertoire d'installation pour plus d'informations sur les commandes et les commutateurs de la ligne de commande.

Vous pouvez créer une entrée de menu contextuel pour les fichiers .tar.gz/.tgz qui appelle la commande ci-dessus en utilisant regedit ou un outil tiers comme stexbar .

À partir de la version 9.04 de 7-zip, il existe une option de ligne de commande permettant d'effectuer l'extraction combinée sans utiliser de stockage intermédiaire pour le fichier .tar ordinaire :

7z x -tgzip -so theinputfile.tgz | 7z x -si -ttar

-tgzip est nécessaire si le fichier d'entrée est nommé .tgz au lieu de .tar.gz.

Vous utilisez Windows XP, donc vous devriez avoir Windows Scripting Host installé par défaut. Ceci étant dit, voici un script JScript WSH pour faire ce dont vous avez besoin. Il suffit de copier le code dans un fichier nommé xtract.bat ou quelque chose du genre (peut être n'importe quoi tant qu'il porte l'extension .bat), et de le lancer :

xtract.bat example.tar.gz

Par défaut, le script vérifiera le dossier du script, ainsi que la variable d'environnement PATH de votre système pour 7z.exe. Si vous souhaitez modifier l'apparence du script, vous pouvez changer la variable SevenZipExe en haut du script pour le nom de l'exécutable de votre choix. (Par exemple, 7za.exe ou 7z-real.exe) Vous pouvez également définir un répertoire par défaut pour l'exécutable en changeant SevenZipDir. Ainsi, si 7z.exe est à C:\Windows\system32z.exe, vous mettriez :

var SevenZipDir = "C:\Windows\system32";

Quoi qu'il en soit, voici le script :

@set @junk=1 /* vim:set ft=javascript:
@echo off
cscript //nologo //e:jscript "%~dpn0.bat" %*
goto :eof
*/
/* Settings */
var SevenZipDir = undefined;
var SevenZipExe = "7z.exe";
var ArchiveExts = ["zip", "tar", "gz", "bzip", "bz", "tgz", "z", "7z", "bz2", "rar"]

/* Multi-use instances */
var WSH = new ActiveXObject("WScript.Shell");
var FSO = new ActiveXObject("Scripting.FileSystemObject");
var __file__ = WScript.ScriptFullName;
var __dir__ = FSO.GetParentFolderName( __file__ );
var PWD = WSH.CurrentDirectory;

/* Prototypes */
(function(obj) {
    obj.has = function object_has(key) {
        return defined(this[key]);
    };
    return obj;
})(this.Object.prototype);

(function(str) {
    str.trim = function str_trim() {
        return this.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
    };
})(this.String.prototype);

(function(arr) {
    arr.contains = function arr_contains(needle) {
        for (var i in this) {
            if (this[i] == needle) {
                return true;
            }
        }
        return false;
    }
})(this.Array.prototype);

/* Utility functions */
function defined(obj)
{
    return typeof(obj) != "undefined";
}

function emptyStr(obj)
{
    return !(defined(obj) && String(obj).length);
}

/* WSH-specific Utility Functions */
function echo()
{
    if(!arguments.length) return;
    var msg = "";
    for (var n = 0; n < arguments.length; n++) {
        msg += arguments[n];
        msg += " ";
    }
    if(!emptyStr(msg))
        WScript.Echo(msg);
}

function fatal(msg)
{
    echo("Fatal Error:", msg);
    WScript.Quit(1);
}

function findExecutable()
{
    // This function searches the directories in;
    // the PATH array for the specified file name;
    var dirTest = emptyStr(SevenZipDir) ? __dir__ : SevenZipDir;
    var exec = SevenZipExe;
    var strTestPath = FSO.BuildPath(dirTest, exec);
    if (FSO.FileExists(strTestPath))
        return FSO.GetAbsolutePathName(strTestPath);

    var arrPath = String(
            dirTest + ";" + 
            WSH.ExpandEnvironmentStrings("%PATH%")
        ).split(";");

    for(var i in arrPath) {
        // Skip empty directory values, caused by the PATH;
        // variable being terminated with a semicolon;
        if (arrPath[i] == "")
            continue;

        // Build a fully qualified path of the file to test for;
        strTestPath = FSO.BuildPath(arrPath[i], exec);

        // Check if (that file exists;
        if (FSO.FileExists(strTestPath))
            return FSO.GetAbsolutePathName(strTestPath);
    }
    return "";
}

function readall(oExec)
{
    if (!oExec.StdOut.AtEndOfStream)
      return oExec.StdOut.ReadAll();

    if (!oExec.StdErr.AtEndOfStream)
      return oExec.StdErr.ReadAll();

    return -1;
}

function xtract(exec, archive)
{
    var splitExt = /^(.+)\.(\w+)$/;
    var strTmp = FSO.GetFileName(archive);
    WSH.CurrentDirectory = FSO.GetParentFolderName(archive);
    while(true) {
        var pathParts = splitExt.exec(strTmp);
        if(!pathParts) {
            echo("No extension detected for", strTmp + ".", "Skipping..");
            break;
        }

        var ext = pathParts[2].toLowerCase();
        if(!ArchiveExts.contains(ext)) {
            echo("Extension", ext, "not recognized. Skipping.");
            break;
        }

        echo("Extracting", strTmp + "..");
        var oExec = WSH.Exec('"' + exec + '" x -bd "' + strTmp + '"');
        var allInput = "";
        var tryCount = 0;

        while (true)
        {
            var input = readall(oExec);
            if (-1 == input) {
                if (tryCount++ > 10 && oExec.Status == 1)
                    break;
                WScript.Sleep(100);
             } else {
                  allInput += input;
                  tryCount = 0;
            }
        }

        if(oExec. ExitCode!= 0) {
            echo("Non-zero return code detected.");
            break;
        }

        WScript.Echo(allInput);

        strTmp = pathParts[1];
        if(!FSO.FileExists(strTmp))
            break;
    }
    WSH.CurrentDirectory = PWD;
}

function printUsage()
{
    echo("Usage:\r\n", __file__ , "archive1 [archive2] ...");
    WScript.Quit(0);
}

function main(args)
{
    var exe = findExecutable();
    if(emptyStr(exe))
        fatal("Could not find 7zip executable.");

    if(!args.length || args(0) == "-h" || args(0) == "--help" || args(0) == "/?")
        printUsage();

    for (var i = 0; i < args.length; i++) {
        var archive = FSO.GetAbsolutePathName(args(i));
        if(!FSO.FileExists(archive)) {
            echo("File", archive, "does not exist. Skipping..");
            continue;
        }
        xtract(exe, archive);
    }
    echo("\r\nDone.");
}

main(WScript.Arguments.Unnamed);

Comme vous pouvez le constater, 7-Zip n'est pas très doué pour cela. Depuis 2009, les gens demandent une opération atomique (http://sourceforge.net/p/sevenzip/discussion/45797/thread/5eb1b8d5)tarball. Voici un petit programme (490 KB) dans Go qui peut le faire, je l'ai compilé pour vous.

package main
import (
  "archive/tar"
  "compress/gzip"
  "flag"
  "fmt"
  "io"
  "os"
  "strings"
 )

func main() {
  flag.Parse() // get the arguments from command line
  sourcefile := flag.Arg(0)
  if sourcefile == "" {
    fmt.Println("Usage : go-untar sourcefile.tar.gz")
    os.Exit(1)
  }
  file, err := os.Open(sourcefile)
  if err != nil {
    fmt.Println(err)
    os.Exit(1)
  }
  defer file.Close()
  var fileReader io.ReadCloser = file
  // just in case we are reading a tar.gz file,
  // add a filter to handle gzipped file
  if strings.HasSuffix(sourcefile, ".gz") {
    if fileReader, err = gzip.NewReader(file); err != nil {
      fmt.Println(err)
      os.Exit(1)
    }
    defer fileReader.Close()
  }
  tarBallReader := tar.NewReader(fileReader)
  // Extracting tarred files
  for {
    header, err := tarBallReader.Next()
    if err != nil {
      if err == io.EOF {
        break
      }
      fmt.Println(err)
      os.Exit(1)
    }
    // get the individual filename and extract to the current directory
    filename := header.Name
    switch header.Typeflag {
    case tar.TypeDir:
      // handle directory
      fmt.Println("Creating directory :", filename)
      // or use 0755 if you prefer
      err = os.MkdirAll(filename, os.FileMode(header.Mode))
      if err != nil {
        fmt.Println(err)
        os.Exit(1)
      }
    case tar.TypeReg:
      // handle normal file
      fmt.Println("Untarring :", filename)
      writer, err := os.Create(filename)
      if err != nil {
        fmt.Println(err)
        os.Exit(1)
      }
      io.Copy(writer, tarBallReader)
      err = os.Chmod(filename, os.FileMode(header.Mode))
      if err != nil {
        fmt.Println(err)
        os.Exit(1)
      }
      writer.Close()
    default:
      fmt.Printf("Unable to untar type : %c in file %s", header.Typeflag,
      filename)
    }
  }
}

À partir de Windows 10 build 17063, les versions tar et curl sont supportées, il est donc possible de décompresser un fichier .tar.gz en une seule étape en utilisant la commande tar, comme ci-dessous.

tar -xzvf your_archive.tar.gz

Tapez tar --help pour plus d'informations sur tar.

7za fonctionne correctement comme ci-dessous :

7za.exe x D:\pkg-temp\Prod-Rtx-Service.tgz -so | 7za.exe x -si -ttar -oD:\pkg-temp\Prod-Rtx-Service