El comando de parche de Linux le permite transferir los cambios de un conjunto de archivos a otro conjunto de archivos de forma rápida y segura. Aprenda a utilizar el parche de forma sencilla.

Los comandos patch y diff

Imagina que tienes un archivo de texto en tu computadora. Recibe una versión modificada de ese archivo de texto de otra persona. ¿Cómo transfiere rápidamente todos los cambios del archivo modificado a su archivo original? Ahí es donde entran en juego patch y diff. patch y diff se encuentran en Linux y otros sistemas operativos similares a Unix, como macOS.

El comando diff examina dos versiones diferentes de un archivo y enumera las diferencias entre ellos. Las diferencias se pueden almacenar en un archivo llamado archivo de parche.

El comando patch puede leer un archivo de parche y usar el contenido como un conjunto de instrucciones. Siguiendo esas instrucciones, los cambios en el archivo modificado son replicado en el original archivo.

Ahora imagine que ese proceso ocurre en un directorio completo de archivos de texto. Todo de una vez. Ese es el poder del parche.

A veces no te envían los archivos modificados. Todo lo que se le envía es el archivo de parche. ¿Por qué enviar docenas de archivos cuando puede enviar un archivo o publicar un archivo para descargarlo fácilmente?

¿Qué se hace con el archivo de parche para parchear realmente sus archivos? Aparte de ser casi un trabalenguas, también es una buena pregunta. Lo guiaremos en este artículo.

El comando patch lo utilizan con mayor frecuencia personas que trabajan con archivos de código fuente de software, pero funciona igualmente bien con cualquier conjunto de archivos de texto, sea cual sea su propósito, código fuente o no.

Nuestro escenario de ejemplo

En este escenario, estamos en un directorio llamado trabajo que contiene otros dos directorios. Uno se llama en funcionamiento y el otro se llama último. El directorio de trabajo contiene un conjunto de archivos de código fuente. El directorio más reciente contiene la versión más reciente de esos archivos de código fuente, algunos de los cuales han sido modificados.

  Cómo eliminar un usuario en Linux (y eliminar todos los rastros)

Para estar seguro, el directorio de trabajo es una copia de la versión actual de los archivos de texto. No es la única copia de ellos.

Encontrar las diferencias entre dos versiones de un archivo

El comando diff encuentra las diferencias entre dos archivos. Su acción predeterminada es listar las líneas modificadas en la ventana del terminal.

Un archivo se llama slang.c. Compararemos la versión del directorio de trabajo con la del directorio más reciente.

La opción -u (unificada) le dice a diff que también enumere algunas de las líneas de texto no modificadas antes y después de cada una de las secciones cambiadas. Estas líneas se denominan líneas de contexto. Ayudan al comando patch a localizar con precisión dónde se debe realizar un cambio en el archivo original.

Proporcionamos los nombres de los archivos para que diff sepa qué archivos comparar. Primero se enumera el archivo original, luego el archivo modificado. Este es el comando que emitimos para diff:

diff -u working/slang.c latest/slang.c

diff -u trabajando / slang.s latest / slang.c en una ventana de terminal

diff produce una lista de salida que muestra las diferencias entre los archivos. Si los archivos fueran idénticos, no se incluiría ningún resultado en la lista. Ver este tipo de salida de diff confirma que existen diferencias entre las dos versiones de archivo y que el archivo original necesita un parche.

salida de diff en una ventana de terminal

Hacer un archivo de parche

Para capturar esas diferencias en un archivo de parche, use el siguiente comando. Es el mismo comando que el anterior, con la salida de diff redirigida a un archivo llamado slang.patch.

diff -u working/slang.c latest/slang.c > slang.patch

diff -u working / slang.c latest / slang.c> slang.patch in a terminal window ”width =” 646 ″ height = ”57 ″ onload =” pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (this); ”  onerror = ”this.onerror = null; pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (this);”> </p>
<p> El nombre del archivo de parche es arbitrario.  Puedes llamarlo como quieras.  Darle una extensión «.patch» es una buena idea;  sin embargo, ya que deja claro qué tipo de archivo es. </p>
<p> Para hacer que el parche actúe sobre el archivo de parche y modificar el archivo de trabajo / slang.c, use el siguiente comando.  La opción -u (unificado) le permite al parche saber que el archivo del parche contiene líneas de contexto unificadas.  En otras palabras, usamos la opción -u con diff, por lo que usamos la opción -u con parche. </p>
<div style=

parche -u working.slang.c -i slang.patch

Si todo va bien, hay una sola línea de salida que le indica que parche está parcheando el archivo.

Hacer una copia de seguridad del archivo original

Podemos indicarle al parche que haga una copia de seguridad de los archivos parcheados antes de que se modifiquen mediante la opción -b (copia de seguridad). La opción -i (entrada) le dice a patch el nombre del archivo de parche a usar:

patch -u -b working.slang.c -i slang.patch

parche -u working.slang.c -i slang.patch en una ventana de terminal

El archivo está parcheado como antes, sin diferencias visibles en la salida. Sin embargo, si observa la carpeta de trabajo, verá que se ha creado el archivo llamado slang.c.orig. Las marcas de fecha y hora de los archivos muestran que slang.c.orig es el archivo original y slang.c es un archivo nuevo creado por parche.

salida de ls en una ventana de terminal

Usando diff con directorios

Podemos usar diff para crear un archivo de parche que contenga todas las diferencias entre los archivos en dos directorios. Luego podemos usar ese archivo de parche con parche para aplicar esas diferencias a los archivos en la carpeta de trabajo con un solo comando.

Las opciones que usaremos con diff son la opción -u (contexto unificado) que hemos usado anteriormente, la opción -r (recursiva) para hacer que diff busque en cualquier subdirectorio y la opción -N (nuevo archivo).

La opción -N le dice a diff cómo manejar archivos en el directorio más reciente que no están en el directorio de trabajo. Obliga a diff a poner instrucciones en el archivo de parche para que el parche cree archivos que están presentes en el directorio más reciente pero que faltan en el directorio de trabajo.

Puede agrupar las opciones para que utilicen un solo guión (-).

Tenga en cuenta que solo proporcionamos los nombres de directorio, no le estamos diciendo a diff que mire archivos específicos:

diff -ruN working/ latest/ > slang.patch

diff -ruN working / latest /> slang.patch ”width =” 646 ″ height = ”77 ″ onload =” pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (this); ”  onerror = ”this.onerror = null; pagespeed.lazyLoadImages.loadIfVisibleAndMaybeBeacon (this);”> </p>
<div style=

Echando un vistazo dentro del archivo de parche

Echemos un vistazo rápido al archivo de parche. Usaremos menos para ver su contenido.

menos slang.patch en una ventana de terminal

La parte superior del archivo muestra las diferencias entre las dos versiones de slang.c.

menos slang.patch que muestra la parte superior del archivo en una ventana de terminal

Desplazándonos hacia abajo en el archivo de parche, vemos que luego describe los cambios en otro archivo llamado structs.h. Esto verifica que el archivo de parche definitivamente contiene las diferencias entre las diferentes versiones de varios archivos.

menos slang.patch que muestra la mitad del archivo en una ventana de terminal

Mira antes de saltar

Parchear una gran colección de archivos puede ser un poco desconcertante, así que vamos a utilizar la opción –dry-run para comprobar que todo está bien antes de dar el paso y comprometernos a realizar los cambios.

La opción –dry-run le dice a patch que haga todo, además de modificar los archivos. patch realizará todas sus comprobaciones previas al vuelo en los archivos y, si encuentra algún problema, lo informará. De cualquier forma, no se modifica ningún archivo.

Si no se reportan problemas, podemos repetir el comando sin la opción –dry-run y parchear nuestros archivos con confianza.

La opción -d (directorio) le dice al parche en qué directorio trabajar.

Tenga en cuenta que no estamos usando la opción -i (entrada) para decirle al parche qué archivo de parche contiene las instrucciones de diff. En cambio, estamos redirigiendo el archivo de parche a parche con <. wp_automatic_readability="17.5">

patch --dry-run -ruN -d working 

parche --dry-run -ruN -d trabajando <slang.patch en una ventana de terminal

Out of the entire directory, diff found two files to patch. The instructions regarding the modifications for those two files have been checked by patch , and no problems have been reported.

Pre-flight checks are OK; we’re ready for take-off.

Patching a Directory

To genuinely apply the patches to the files we use the previous command without the --dry-run option.

patch -ruN -d working 

patch -ruN -d trabajando <slang.patch en una ventana de terminal

Esta vez, cada línea de salida no comienza con "comprobación", cada línea comienza con "parcheo".

Y no se informan problemas. Podemos compilar nuestro código fuente y tendremos la última versión del software.

Resuelva sus diferencias

Esta es, con mucho, la forma más fácil y segura de usar el parche. Copie sus archivos de destino a una carpeta y parchee esa carpeta. Cópielos de nuevo cuando esté satisfecho de que el proceso de parcheo se haya completado sin errores.