compression - para - winzip gratis

¿Hay una forma segura de ejecutar un archivo diferencial en dos archivos comprimidos en zip?

Question

Parece que esto no sería una cosa determinista, o hay una manera de hacerlo de manera confiable?

Answer 1

Confiable: descomprime ambos, dif.

No tengo idea de si esa respuesta es lo suficientemente buena para su uso, pero funciona.

Answer 2

Dejé de intentar usar las herramientas existentes y escribí un pequeño script de bash que me funciona:

#!/bin/bash
# Author: Onno Benschop, [email protected]
# Note: This requires enough space for both archives to be extracted in the tempdir

if [ $# -ne 2 ] ; then
  echo Usage: $(basename "$0") zip1 zip2
  exit
fi

# Make temporary directories
archive_1=$(mktemp -d)
archive_2=$(mktemp -d)

# Unzip the archives
unzip -qqd"${archive_1}" "$1"
unzip -qqd"${archive_2}" "$2"

# Compare them
diff -r "${archive_1}" "${archive_2}"

# Remove the temporary directories
rm -rf "${archive_1}" "${archive_2}"

Answer 3

En general, no se puede evitar descomprimir y luego comparar. Los diferentes compresores darán lugar a diferentes flujos de bytes DEFLATEd, que cuando INFLATEd dan como resultado el mismo texto original. No puedes simplemente comparar los datos DEFLATEd, uno con otro. Eso fallará en algunos casos.

Pero en un escenario ZIP , hay un CRC32 calculado y almacenado para cada entrada. Por lo tanto, si desea verificar los archivos, simplemente puede comparar el CRC32 almacenado asociado a cada flujo DEFLATEd, con las advertencias sobre las propiedades de unicidad del hash CRC32. Puede ajustarse a sus necesidades para comparar el Nombre de archivo y el CRC.

Necesitaría una biblioteca ZIP que lea los archivos zip y exponga esas cosas como propiedades en el objeto "ZipEntry". DotNetZip lo hará para las aplicaciones .NET.

Answer 4

En realidad, gzip y bzip2 vienen con herramientas dedicadas para hacerlo.

Con gzip:

$ zdiff file1.gz file2.gz

Con bzip2:

$ bzdiff file1.bz2 file2.bz2

Pero tenga en cuenta que para archivos muy grandes, puede que tenga problemas de memoria (originalmente vine aquí para averiguar cómo resolverlos, así que todavía no tengo la respuesta).

Answer 5

Encontré alivio con este sencillo script de Perl: diffzips.pl

Difunde recursivamente cada archivo zip dentro del zip original, lo que es especialmente útil para diferentes formatos de paquetes Java: jar, war y ear.

zipcmp utiliza un enfoque más simple y no retrocede en las cremalleras archivadas.

Answer 6

Esto no es particularmente elegante, pero puede usar la aplicación FileMerge que viene con las herramientas de desarrollo de Mac OS X para comparar el contenido de los archivos zip utilizando un filtro personalizado.

Cree un script ~/bin/zip_filemerge_filter.bash con contenido:

#!/bin/bash
##
#  List the size, CR-32 checksum, and file path of each file in a zip archive,
#  sorted in order by file path.
##
unzip -v -l "${1}" | cut -c 1-9,59-,49-57 | sort -k3
exit $?

Haga el script ejecutable ( chmod +x ~/bin/zip_filemerge_filter.bash ).

Abra FileMerge, abra las Preferencias y vaya a la pestaña "Filtros". Agregue un elemento a la lista con: Extensión: "zip", Filtro: "~ / bin / zip_filemerge_filter.bash $ (ARCHIVO)", Pantalla: Filtrado, Aplicar *: No. (También he agregado el archivador para .jar y archivos .war.)

Luego use FileMerge (o la línea de comando "opendiff" wrapper) para comparar dos archivos .zip.

Esto no le permitirá diferenciar el contenido de los archivos dentro de los archivos zip, sino que le permitirá ver rápidamente qué archivos aparecen en un solo archivo y qué archivos existen en ambos pero tienen diferente contenido (es decir, diferente tamaño y / o suma de comprobación).

Answer 7

Generalmente uso un enfoque como el de @ mrabbit, pero ejecuto 2 comandos de descompresión y difumino la salida según sea necesario. Por ejemplo, necesito comparar 2 archivos WAR de Java.

$ sdiff --width 160 /
   <(unzip -l -v my_num1.war | cut -c 1-9,59-,49-57 | sort -k3) /
   <(unzip -l -v my_num2.war | cut -c 1-9,59-,49-57 | sort -k3)

Resultando en salida como tal:

--------          -------                                                       --------          -------
Archive:                                                                        Archive:
-------- -------- ----                                                          -------- -------- ----
48619281          130 files                                                   | 51043693          130 files
    1116 060ccc56 index.jsp                                                         1116 060ccc56 index.jsp
       0 00000000 META-INF/                                                            0 00000000 META-INF/
     155 b50f41aa META-INF/MANIFEST.MF                                        |      155 701f1623 META-INF/MANIFEST.MF
 Length   CRC-32  Name                                                           Length   CRC-32  Name
    1179 b42096f1 version.jsp                                                       1179 b42096f1 version.jsp
       0 00000000 WEB-INF/                                                             0 00000000 WEB-INF/
       0 00000000 WEB-INF/classes/                                                     0 00000000 WEB-INF/classes/
       0 00000000 WEB-INF/classes/com/                                                 0 00000000 WEB-INF/classes/com/
...
...

Answer 8

Si estás usando gzip, puedes hacer algo como esto:

# diff <(zcat file1.gz) <(zcat file2.gz)

Answer 9

Una solución de python para archivos zip:

import difflib
import zipfile

def diff(filename1, filename2):
    differs = False

    z1 = zipfile.ZipFile(open(filename1))
    z2 = zipfile.ZipFile(open(filename2))
    if len(z1.infolist()) != len(z2.infolist()):
        print "number of archive elements differ: {} in {} vs {} in {}".format(
            len(z1.infolist()), z1.filename, len(z2.infolist()), z2.filename)
        return 1
    for zipentry in z1.infolist():
        if zipentry.filename not in z2.namelist():
            print "no file named {} found in {}".format(zipentry.filename,
                                                        z2.filename)
            differs = True
        else:
            diff = difflib.ndiff(z1.open(zipentry.filename),
                                 z2.open(zipentry.filename))
            delta = ''''.join(x[2:] for x in diff
                            if x.startswith(''- '') or x.startswith(''+ ''))
            if delta:
                differs = True
                print "content for {} differs:/n{}".format(
                    zipentry.filename, delta)
    if not differs:
        print "all files are the same"
        return 0
    return 1

Usar como

diff(filename1, filename2)

Compara los archivos línea por línea en la memoria y muestra los cambios.

Answer 10

WinMerge (solo para Windows) tiene muchas features y una de ellas es:

• Soporte de archivos de archivo utilizando 7-Zip

Answer 11

Más allá de la comparación no tiene ningún problema con esto.

Answer 12

zipcmp compara los archivos zip zip1 y zip2 y comprueba si contienen los mismos archivos, comparando sus nombres, tamaños sin comprimir y CRC. El orden de los archivos y las diferencias de tamaño comprimido se ignoran.

sudo apt-get install zipcmp