recognized - zip file powershell 4

¿Cómo crear un archivo zip con PowerShell?

Question

¿Es posible crear un archivo zip con PowerShell?

Answer 1

¿Por qué nadie mira la documentación? Existe un método compatible para crear un archivo zip vacío y agregar archivos individuales integrados en la misma biblioteca .NET 4.5 a la que hacen referencia todos.

Vea a continuación un ejemplo de código:

# Load the .NET assembly
Add-Type -Assembly ''System.IO.Compression.FileSystem''

# Must be used for relative file locations with .NET functions instead of Set-Location:
[System.IO.Directory]::SetCurrentDirectory(''./Desktop'')

# Create the zip file and open it:
$z = [System.IO.Compression.ZipFile]::Open(''z.zip'', [System.IO.Compression.ZipArchiveMode]::Create)

# Add a compressed file to the zip file:
[System.IO.Compression.ZipFileExtensions]::CreateEntryFromFile($z, ''t.txt'', ''t.txt'')

# Close the file
$z.Dispose()

Le animo a navegar por la documentación si tiene alguna pregunta.

Answer 2

¿Qué pasa con System.IO.Packaging.ZipPackage ?

Requeriría .NET 3.0 o mayor.

#Load some assemblys. (No line break!)
[System.Reflection.Assembly]::Load("WindowsBase, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")

#Create a zip file named "MyZipFile.zip". (No line break!)
$ZipPackage=[System.IO.Packaging.ZipPackage]::Open("C:/MyZipFile.zip",
   [System.IO.FileMode]"OpenOrCreate", [System.IO.FileAccess]"ReadWrite")

#The files I want to add to my archive:
$files = @("/Penguins.jpg", "/Lighthouse.jpg")

#For each file you want to add, we must extract the bytes
#and add them to a part of the zip file.
ForEach ($file In $files)
{
   $partName=New-Object System.Uri($file, [System.UriKind]"Relative")
   #Create each part. (No line break!)
   $part=$ZipPackage.CreatePart($partName, "",
      [System.IO.Packaging.CompressionOption]"Maximum")
   $bytes=[System.IO.File]::ReadAllBytes($file)
   $stream=$part.GetStream()
   $stream.Write($bytes, 0, $bytes.Length)
   $stream.Close()
}

#Close the package when we''re done.
$ZipPackage.Close()

a través de here

Answer 3

Aquí está el código de trabajo, comprimir todos los archivos de una carpeta de origen y crear un archivo zip en la carpeta de destino.

    $DestZip="C:/Destination/"
    $Source = "C:/Source/"

    $folder = Get-Item -Path $Source

    $ZipTimestamp = Get-Date -format yyyyMMdd-HHmmss;
    $ZipFileName  = $DestZip + "Backup_" + $folder.name + "_" + $ZipTimestamp + ".zip" 

    $Source

    set-content $ZipFileName ("PK" + [char]5 + [char]6 + ("$([char]0)" * 18)) 
    # Wait for the zip file to be created.
    while (!(Test-Path -PathType leaf -Path $ZipFileName))
    {    
        Start-Sleep -Milliseconds 20
    } 
    $ZipFile = (new-object -com shell.application).NameSpace($ZipFileName)

    Write-Output (">> Waiting Compression : " + $ZipFileName)       

    #BACKUP - COPY
    $ZipFile.CopyHere($Source) 

    $ZipFileName
    # ARCHIVE

    Read-Host "Please Enter.."

Answer 4

Aquí hay una solución nativa para ps v5, usando cmdlet Compress-Archive Creando archivos Zip usando PowerShell

Answer 5

Aquí hay una versión ligeramente mejorada de la respuesta de sonjz, agrega una opción de sobrescritura.

function Zip-Files(
        [Parameter(Position=0, Mandatory=$true, ValueFromPipeline=$false)]
        [string] $zipfilename,
        [Parameter(Position=1, Mandatory=$true, ValueFromPipeline=$false)]
        [string] $sourcedir,
        [Parameter(Position=2, Mandatory=$false, ValueFromPipeline=$false)]
        [bool] $overwrite)

{
   Add-Type -Assembly System.IO.Compression.FileSystem
   $compressionLevel = [System.IO.Compression.CompressionLevel]::Optimal

    if ($overwrite -eq $true )
    {
        if (Test-Path $zipfilename)
        {
            Remove-Item $zipfilename
        }
    }

    [System.IO.Compression.ZipFile]::CreateFromDirectory($sourcedir, $zipfilename, $compressionLevel, $false)
}

Answer 6

Aquí un ejemplo completo de línea de comandos para iniciar desde cmd.exe o desde ssh o lo que quieras!

powershell.exe -nologo -noprofile -command "&{ Add-Type -A ''System.IO.Compression.FileSystem'' [System.IO.Compression.ZipFile]::CreateFromDirectory(''c:/path/to/source/folder/'', ''c:/path/to/output/file.zip'');}"

Saludos

Answer 7

Cargar la clase [System.IO.IOException] y usar sus métodos es un paso importante para suprimir los errores no deseados, debido al hecho de que es una clase no nativa de PowerShell, así que espere varios contextos de errores sin ella.

Controlé los errores de mi secuencia de comandos a la T, pero obtuve una gran cantidad de color rojo extra ''existe'' al usar la clase [System.IO.Compression.ZipFile]

function zipFiles(
    [Parameter(Position=0, Mandatory=$true]
    [string] $sourceFolder,
    [Parameter(Position=1, Mandatory=$true]
    [string]$zipFileName,
    [Parameter(Position=2, Mandatory=$false]
    [bool]$overwrite)

{   
Add-Type -Assembly System.IO
Add-Type -Assembly System.IO.Compression.FileSystem

$compressionLevel = [System.IO.Compression.CompressionLevel]::Optimal

$directoryTest = (Test-Path $dailyBackupDestFolder)
$fileTest = (Test-Path $zipFileName)

if ( $directoryTest -eq $false) 
{ 
    New-Item -ItemType Directory -Force -Path $dailyBackupDestFolder 
}

     if ( $fileTest -eq $true)
     {
           if ($overwrite -eq $true ){Remove-Item $zipFileName}
     }   


    try
    {
         [System.IO.Compression.ZipFile]::CreateFromDirectory($sourceFolder,$zipFileName,$compressionLevel)       

    }
    catch [System.IO.IOException] 
    {
       Write-Output ($dateTime + '' | '' + $_.Exception.Message ) | Out-File $logFile -append -force 
    }
} 

Lo que estoy haciendo aquí es capturar estos errores de E / S, como acceder a archivos que ya existen, capturar ese error y dirigirlo a un archivo de registro que estoy manteniendo con un programa más grande.

Answer 8

Dando debajo de otra opción. Esto comprimirá una carpeta completa y escribirá el archivo en una ruta determinada con el nombre dado.

Requiere .NET 3 o superior

Add-Type -assembly "system.io.compression.filesystem"

$source = ''Source path here''    
$destination = "c:/output/dummy.zip"

If(Test-path $destination) {Remove-item $destination}

[io.compression.zipfile]::CreateFromDirectory($Source, $destination)

Answer 9

El enfoque iónico oscila:

https://dotnetzip.codeplex.com/wikipage?title=PS-Examples

Soporta contraseñas, otros métodos criptográficos, etc.

Answer 10

En caso de que tengas instalado WinRAR:

function ZipUsingRar([String] $directory, [String] $zipFileName)
{
  Write-Output "Performing operation ""Zip File"" on Target ""Item: $directory Destination:"
  Write-Output ($zipFileName + """")
  $pathToWinRar = "c:/Program Files/WinRAR/WinRar.exe";
  [Array]$arguments = "a", "-afzip", "-df", "-ep1", "$zipFileName", "$directory";
  & $pathToWinRar $arguments;
}

El significado de los argumentos: afzip crea un archivo zip, df elimina archivos, ep1 no crea una ruta de directorio completa dentro del archivo

Answer 11

Este script itera todos los directorios y comprime cada uno.

Get-ChildItem -Atributos d | foreach {write-zip $ .Name "$ ($ .Name) .zip"}

Answer 12

Esto es realmente oscuro pero funciona. 7za.exe es una versión independiente de 7zip y está disponible con el paquete de instalación.

# get files to be send
$logFiles = Get-ChildItem C:/Logging/*.* -Include *.log | where {$_.Name -match $yesterday} 

foreach ($logFile in $logFiles)
{
    Write-Host ("Processing " + $logFile.FullName)

    # compress file
    & ./7za.exe a -mmt=off ($logFile.FullName + ".7z") $logFile.FullName

}

Answer 13

Esto también debería funcionar para comprimir un solo archivo sin usar una carpeta temporal y usar .Net 4.5 nativo, convertido de C # desde esta answer . Utiliza una mejor sintaxis usando la sintaxis de here .

Uso:

ZipFiles -zipFilename output.zip -sourceFile input.sql -filename name.inside.zip.sql

Código:

function ZipFiles([string] $zipFilename, [string] $sourceFile, [string] $filename)
{
    $fullSourceFile = (Get-Item -Path "$sourceFile" -Verbose).FullName
    $fullZipFile = (Get-Item -Path "$zipFilename" -Verbose).FullName

    Add-Type -AssemblyName System.IO
    Add-Type -AssemblyName System.IO.Compression
    Add-Type -AssemblyName System.IO.Compression.FileSystem

    Using-Object ($fs = New-Object System.IO.FileStream($fullZipFile, [System.IO.FileMode]::Create)) {
         Using-Object ($arch = New-Object System.IO.Compression.ZipArchive($fs, [System.IO.Compression.ZipArchiveMode]::Create)) {
             [System.IO.Compression.ZipFileExtensions]::CreateEntryFromFile($arch, $fullSourceFile, $filename)
        }
    }
}

Utilizando:

function Using-Object
{
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true)]
        [AllowEmptyString()]
        [AllowEmptyCollection()]
        [AllowNull()]
        [Object]
        $InputObject,

        [Parameter(Mandatory = $true)]
        [scriptblock]
        $ScriptBlock
    )

    try
    {
        . $ScriptBlock
    }
    finally
    {
        if ($null -ne $InputObject -and $InputObject -is [System.IDisposable])
        {
            $InputObject.Dispose()
        }
    }
}

Answer 14

Instale 7zip (o descargue la versión de línea de comandos en su lugar) y use este método de PowerShell:

function create-7zip([String] $aDirectory, [String] $aZipfile){
    [string]$pathToZipExe = "$($Env:ProgramFiles)/7-Zip/7z.exe";
    [Array]$arguments = "a", "-tzip", "$aZipfile", "$aDirectory", "-r";
    & $pathToZipExe $arguments;
}

Puedes llamarlo así:

create-7zip "c:/temp/myFolder" "c:/temp/myFolder.zip"

Answer 15

Los comandos de línea de comandos completos en Windows para comprimir y extraer directorio son los siguientes:

• Para la compresión:

powershell.exe -nologo -noprofile -command "& { Add-Type -A ''System.IO.Compression.FileSystem''; [IO.Compression.ZipFile]::CreateFromDirectory(''C:/Indus'',''C:/Indus.zip''); }"

• Para la extracción:

powershell.exe -nologo -noprofile -command "& { Add-Type -A ''System.IO.Compression.FileSystem'';[IO.Compression.ZipFile]::ExtractToDirectory(''C:/Indus.zip'',''C:/Indus''); }"

Answer 16

Para la compresión, usaría una biblioteca (7-Zip es bueno como sugiere Michal ).

Si instala 7-Zip , el directorio instalado contendrá 7z.exe que es una aplicación de consola.
Puede invocarlo directamente y usar cualquier opción de compresión que desee.

Si desea participar con la DLL, eso también debería ser posible.
7-Zip es freeware y de código abierto.

Answer 17

PowerShell v5.0 agrega los cmdlets Compress-Archive y Expand-Archive . Las páginas enlazadas tienen ejemplos completos, pero la esencia de esto es:

# Create a zip file with the contents of C:/Stuff/
Compress-Archive -Path C:/Stuff -DestinationPath archive.zip

# Add more files to the zip file
# (Existing files in the zip file with the same name are replaced)
Compress-Archive -Path C:/OtherStuff/*.txt -Update -DestinationPath archive.zip

# Extract the zip file to C:/Destination/
Expand-Archive -Path archive.zip -DestinationPath C:/Destination

Answer 18

Si alguien necesita comprimir un solo archivo (y no una carpeta): http://blogs.msdn.com/b/jerrydixon/archive/2014/08/08/zipping-a-single-file-with-powershell.aspx

[CmdletBinding()]
Param(
     [Parameter(Mandatory=$True)]
     [ValidateScript({Test-Path -Path $_ -PathType Leaf})]
     [string]$sourceFile,

     [Parameter(Mandatory=$True)]
     [ValidateScript({-not(Test-Path -Path $_ -PathType Leaf)})]
     [string]$destinationFile
) 

<#
     .SYNOPSIS
     Creates a ZIP file that contains the specified innput file.

     .EXAMPLE
     FileZipper -sourceFile c:/test/inputfile.txt 
                -destinationFile c:/test/outputFile.zip
#> 

function New-Zip
{
     param([string]$zipfilename)
     set-content $zipfilename 
          ("PK" + [char]5 + [char]6 + ("$([char]0)" * 18))
     (dir $zipfilename).IsReadOnly = $false
}

function Add-Zip
{
     param([string]$zipfilename) 

     if(-not (test-path($zipfilename)))
     {
          set-content $zipfilename 
               ("PK" + [char]5 + [char]6 + ("$([char]0)" * 18))
          (dir $zipfilename).IsReadOnly = $false    

     }

     $shellApplication = new-object -com shell.application
     $zipPackage = $shellApplication.NameSpace($zipfilename)


     foreach($file in $input) 
     { 
          $zipPackage.CopyHere($file.FullName)
          Start-sleep -milliseconds 500
     }
}

dir $sourceFile | Add-Zip $destinationFile

Answer 19

Una alternativa pura de PowerShell que funciona con PowerShell 3 y .NET 4.5 (si puede usarlo):

function ZipFiles( $zipfilename, $sourcedir )
{
   Add-Type -Assembly System.IO.Compression.FileSystem
   $compressionLevel = [System.IO.Compression.CompressionLevel]::Optimal
   [System.IO.Compression.ZipFile]::CreateFromDirectory($sourcedir,
        $zipfilename, $compressionLevel, $false)
}

Simplemente pase la ruta completa al archivo zip que desea crear y la ruta completa al directorio que contiene los archivos que desea comprimir.

Answer 20

Una forma nativa con el último marco .NET 4.5, pero sin características por completo:

Creación:

Add-Type -Assembly "System.IO.Compression.FileSystem" ;
[System.IO.Compression.ZipFile]::CreateFromDirectory("c:/your/directory/to/compress", "yourfile.zip") ;

Extracción:

Add-Type -Assembly "System.IO.Compression.FileSystem" ;
[System.IO.Compression.ZipFile]::ExtractToDirectory("yourfile.zip", "c:/your/destination") ;

Como se mencionó, totalmente sin características, así que no espere una marca de sobrescritura .

ACTUALIZACIÓN: vea a continuación otros desarrolladores que se han expandido a lo largo de los años ...

Answer 21

Utilizo este fragmento de código para revisar la carpeta de copias de seguridad de mi base de datos en busca de archivos de copia de seguridad aún no comprimidos, comprimirlos con 7-Zip y finalmente eliminar los archivos *.bak para ahorrar algo de espacio en el disco. Los archivos de aviso se ordenan por longitud (de menor a mayor) antes de la compresión para evitar que algunos archivos no se compriman.

$bkdir = "E:/BackupsPWS"
$7Zip = ''C:/"Program Files"/7-Zip/7z.exe''

get-childitem -path $bkdir | Sort-Object length |
where
{
    $_.extension -match ".(bak)" -and
    -not (test-path ($_.fullname -replace "(bak)", "7z"))
} |
foreach
{
    $zipfilename = ($_.fullname -replace "bak", "7z")
    Invoke-Expression "$7Zip a $zipfilename $($_.FullName)"
}
get-childitem -path $bkdir |
where {
    $_.extension -match ".(bak)" -and
   (test-path ($_.fullname -replace "(bak)", "7z"))
} |
foreach { del $_.fullname }

Aquí puede consultar un script de PowerShell para realizar copias de seguridad, comprimir y transferir esos archivos a través de FTP .

Answer 22

Editar dos : este código es un kluge feo, feo de los días anteriores. No lo quieres.

Esto comprime el contenido de ./in ./out.zip to ./out.zip con System.IO.Packaging.ZipPackage siguiendo el ejemplo here

$zipArchive = $pwd.path + "/out.zip"
[System.Reflection.Assembly]::Load("WindowsBase,Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")
$ZipPackage=[System.IO.Packaging.ZipPackage]::Open($zipArchive,
  [System.IO.FileMode]"OpenOrCreate", [System.IO.FileAccess]"ReadWrite")
$in = gci ./in | select -expand fullName
[array]$files = $in -replace "C:","" -replace "//","/"
ForEach ($file In $files)
{
   $partName=New-Object System.Uri($file, [System.UriKind]"Relative")
   $part=$ZipPackage.CreatePart($partName, "application/zip",
      [System.IO.Packaging.CompressionOption]"Maximum")
   $bytes=[System.IO.File]::ReadAllBytes($file)
   $stream=$part.GetStream()
   $stream.Write($bytes, 0, $bytes.Length)
   $stream.Close()
}
$ZipPackage.Close()

Edición: No Unreliable para archivos más grandes, tal vez> 10 mb, YMMV. Something que ver con la evidencia de aplicaciones y almacenamiento aislado. El approach más amigable de .NET 4.5 funciona bien en PS v3, pero quería más memoria en mi caso. Para usar .NET 4 de PS v2, los archivos de configuración necesitan un tweak unsupported .

Answer 23

Si se dirige a CodePlex y toma las extensiones de la comunidad de PowerShell , puede usar su cmdlet write-zip .

Ya que

CodePlex está en modo de solo lectura en preparación para el cierre

Puedes ir a la Galería PowerShell .

Answer 24

function Zip-File
    {
    param (
    [string]$ZipName,
    [string]$SourceDirectory 

    )
       Add-Type -Assembly System.IO.Compression.FileSystem
       $Compress = [System.IO.Compression.CompressionLevel]::Optimal
       [System.IO.Compression.ZipFile]::CreateFromDirectory($SourceDirectory,
            $ZipName, $Compress, $false)
    }

Nota:
ZipName: Ruta completa del archivo Zip que desea crear.

SourceDirectory: ruta completa al directorio que contiene los archivos que desea comprimir.