文件解压

复制import zipfile
import tarfile
import py7zr
import rarfile

# 自动检测格式并解压到目标目录
def extract(filepath, dest):
    if filepath.endswith('.zip'):
        with zipfile.ZipFile(filepath, 'r') as z:
            z.extractall(dest)
    elif filepath.endswith('.tar.gz') or filepath.endswith('.tgz'):
        with tarfile.open(filepath, 'r:gz') as t:
            t.extractall(dest)
    elif filepath.endswith('.tar.bz2'):
        with tarfile.open(filepath, 'r:bz2') as t:
            t.extractall(dest)
    elif filepath.endswith('.7z'):
        with py7zr.SevenZipFile(filepath, mode='r') as z:
            z.extractall(path=dest)
    elif filepath.endswith('.rar'):
        # rarfile 只读，需系统安装 unrar
        with rarfile.RarFile(filepath) as rf:
            rf.extractall(dest)
    else:
        raise ValueError(f'Unsupported format: {filepath}')

if __name__ == '__main__':
    extract('example.zip', './output')

复制package main

import (
	"archive/tar"
	"archive/zip"
	"compress/gzip"
	"io"
	"os"
	"path/filepath"
	"strings"
)

func extractZip(src, dest string) error {
	r, err := zip.OpenReader(src)
	if err != nil {
		return err
	}
	defer r.Close()

	for _, f := range r.File {
		fpath := filepath.Join(dest, f.Name)
		if f.FileInfo().IsDir() {
			os.MkdirAll(fpath, os.ModePerm)
			continue
		}
		if err := os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
			return err
		}
		rc, err := f.Open()
		if err != nil {
			return err
		}
		out, err := os.Create(fpath)
		if err != nil {
			rc.Close()
			return err
		}
		io.Copy(out, rc)
		out.Close()
		rc.Close()
	}
	return nil
}

func extractTarGz(src, dest string) error {
	f, err := os.Open(src)
	if err != nil {
		return err
	}
	defer f.Close()

	gzf, err := gzip.NewReader(f)
	if err != nil {
		return err
	}
	defer gzf.Close()

	tarReader := tar.NewReader(gzf)
	for {
		header, err := tarReader.Next()
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}
		fpath := filepath.Join(dest, header.Name)
		switch header.Typeflag {
		case tar.TypeDir:
			os.MkdirAll(fpath, os.ModePerm)
		case tar.TypeReg:
			os.MkdirAll(filepath.Dir(fpath), os.ModePerm)
			out, err := os.Create(fpath)
			if err != nil {
				return err
			}
			io.Copy(out, tarReader)
			out.Close()
		}
	}
	return nil
}

func main() {
	src := "archive.zip"
	dest := "./output"
	if strings.HasSuffix(src, ".zip") {
		extractZip(src, dest)
	} else if strings.HasSuffix(src, ".tar.gz") {
		extractTarGz(src, dest)
	}
}

复制const fs = require('fs');
const path = require('path');
const { createGunzip } = require('zlib');
const tar = require('tar-stream');
const AdmZip = require('adm-zip');

// 解压 zip
function extractZip(src, dest) {
  const zip = new AdmZip(src);
  zip.extractAllTo(dest, true);
}

// 解压 tar.gz
function extractTarGz(src, dest) {
  return new Promise((resolve, reject) => {
    const extract = tar.extract();
    const gunzip = createGunzip();

    extract.on('entry', (header, stream, next) => {
      const fpath = path.join(dest, header.name);
      if (header.type === 'directory') {
        fs.mkdirSync(fpath, { recursive: true });
        next();
      } else {
        fs.mkdirSync(path.dirname(fpath), { recursive: true });
        const out = fs.createWriteStream(fpath);
        stream.pipe(out);
        stream.on('end', next);
      }
    });

    extract.on('finish', resolve);
    extract.on('error', reject);

    fs.createReadStream(src).pipe(gunzip).pipe(extract);
  });
}

// 使用示例
// extractZip('example.zip', './output');
// extractTarGz('example.tar.gz', './output').then(() => console.log('done'));