patch命令

亦凉 2022-04-10 09:54 750阅读 0赞

### 一、命令概括 ###

##### 1、命令作用 #####

*  patch命令用于为特定软件包打补丁，diff命令可以生成补丁文件

##### 2、参数选项 #####

Usage: patch [OPTION]... [ORIGFILE [PATCHFILE]]
    
    Input options:
    
      -p NUM  --strip=NUM  Strip NUM leading components from file names.
      -F LINES  --fuzz LINES  Set the fuzz factor to LINES for inexact matching.
      -l  --ignore-whitespace  Ignore white space changes between patch and input.
    
      -c  --context  Interpret the patch as a context difference.
      -e  --ed  Interpret the patch as an ed script.
      -n  --normal  Interpret the patch as a normal difference.
      -u  --unified  Interpret the patch as a unified difference.
    
      -N  --forward  Ignore patches that appear to be reversed or already applied.
      -R  --reverse  Assume patches were created with old and new files swapped.
    
      -i PATCHFILE  --input=PATCHFILE  Read patch from PATCHFILE instead of stdin.
    
    Output options:
    
      -o FILE  --output=FILE  Output patched files to FILE.
      -r FILE  --reject-file=FILE  Output rejects to FILE.
    
      -D NAME  --ifdef=NAME  Make merged if-then-else output using NAME.
      --merge  Merge using conflict markers instead of creating reject files.
      -E  --remove-empty-files  Remove output files that are empty after patching.
    
      -Z  --set-utc  Set times of patched files, assuming diff uses UTC (GMT).
      -T  --set-time  Likewise, assuming local time.
    
      --quoting-style=WORD   output file names using quoting style WORD.
        Valid WORDs are: literal, shell, shell-always, c, escape.
        Default is taken from QUOTING_STYLE env variable, or 'shell' if unset.
    
    Backup and version control options:
    
      -b  --backup  Back up the original contents of each file.
      --backup-if-mismatch  Back up if the patch does not match exactly.
      --no-backup-if-mismatch  Back up mismatches only if otherwise requested.
    
      -V STYLE  --version-control=STYLE  Use STYLE version control.
    	STYLE is either 'simple', 'numbered', or 'existing'.
      -B PREFIX  --prefix=PREFIX  Prepend PREFIX to backup file names.
      -Y PREFIX  --basename-prefix=PREFIX  Prepend PREFIX to backup file basenames.
      -z SUFFIX  --suffix=SUFFIX  Append SUFFIX to backup file names.
    
      -g NUM  --get=NUM  Get files from RCS etc. if positive; ask if negative.
    
    Miscellaneous options:
    
      -t  --batch  Ask no questions; skip bad-Prereq patches; assume reversed.
      -f  --force  Like -t, but ignore bad-Prereq patches, and assume unreversed.
      -s  --quiet  --silent  Work silently unless an error occurs.
      --verbose  Output extra information about the work being done.
      --dry-run  Do not actually change any files; just print what would happen.
      --posix  Conform to the POSIX standard.
    
      -d DIR  --directory=DIR  Change the working directory to DIR first.
      --reject-format=FORMAT  Create 'context' or 'unified' rejects.
      --binary  Read and write data in binary mode.
      --read-only=BEHAVIOR  How to handle read-only input files: 'ignore' that they
                            are read-only, 'warn' (default), or 'fail'.
    
      -v  --version  Output version info.
      --help  Output this help.

### 二、举例 ###

*  实验的基本步骤。我打算是建立一个级联目录./x/xx/xxx/，在xxx目录下建立两个不同的文件xxx1,xxx2。然后在xxx目录下用diff命令，建立一个补丁文件xxx.patch，在xx目录下建立一个补丁文件xx.patch，在x目录下建立一个补丁文件x.patch。然后在这三个目录下实验（）。

##### 准备 #####

*  1、建立实验目录

[King@Fedora ~]$ mkdir -pv x/xx/xxx
    mkdir: 已创建目录 “x”
    mkdir: 已创建目录 “x/xx”
    mkdir: 已创建目录 “x/xx/xxx”

*  2、进入xxx目录下创建xxx1,xxx2

[King@Fedora ~]$ cd x/xx/xxx
    [King@Fedora xxx]$ cat >> xxx1 << EOF
    > 111111
    > 111111
    > EOF

[King@Fedora xxx]$ cat >> xxx2 << EOF
    > 111111
    > 222222
    > EOF

[King@Fedora xxx]$ diff -y xxx1 xxx2
    111111        111111
    111111       | 222222

*  3、在xxx目录下创建补丁文件xxx.patch，并查看。

[King@Fedora xxx]$ diff -Naru xxx1 xxx2 > xxx.patch
    [King@Fedora xxx]$ cat xxx.patch 
    - - - xxx1 2009-12-19 22:28:26.582959182 +0800
    +++ xxx2 2009-12-19 22:28:42.798928591 +0800
     @@ -1,2 +1,2 @@
     111111
    -111111
    +222222

*  4、在xx目录下创建补丁文件xx.patch，并查看

[King@Fedora xxx]$ cd ..
    [King@Fedora xx]$ diff -Naru xxx/xxx1 xxx/xxx2 > xx.patch
    [King@Fedora xx]$ cat xx.patch 
    --- xxx/xxx1 2009-12-19 22:28:26.582959182 +0800
     +++ xxx/xxx2 2009-12-19 22:28:42.798928591 +0800
     @@ -1,2 +1,2 @@
     111111
    -111111
    +222222

*  5、在x目录下创建补丁文件x.patch，并查看

[King@Fedora xx]$ cd ..
    [King@Fedora x]$ diff -Nu xx/xxx/xxx1 xx/xxx/xxx2 > x.patch
    [King@Fedora x]$ cat x.patch 
    --- xx/xxx/xxx1 2009-12-19 22:28:26.582959182 +0800
     +++ xx/xxx/xxx2 2009-12-19 22:28:42.798928591 +0800
     @@ -1,2 +1,2 @@
     111111
    -111111
    +222222

*  6、现将patch文件都拷贝到xxx目录下去。

[King@Fedora x]$ cp x.patch xx/xxx/
    [King@Fedora x]$ cp xx/xx.patch xx/xxx/

##### 实验 #####

[King@Fedora x]$ cd xx/xxx
    [King@Fedora xxx]$ ls
    x.patch xx.patch xxx1 xxx2 xxx.patch
     
    //在当前路径下打当前路径的补丁（当前路径的补丁就是当时在制作补丁的时候在该路径下做的）
    [King@Fedora xxx]$ patch-p0< xxx.patch #用第二个的 补丁 修改 第一个文件
    patching file xxx1
    //这里发现文件被修改
    [King@Fedora xxx]$ cat xxx1
    111111
    222222
    //恢复，再次执行patch-p0< xxx.patch也会还原
    [King@Fedora xxx]$ patch -RE < xxx.patch #用第一个的 补丁 修改 第一个文件
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    111111
     
    //在当前路径打上级路径的补丁（这里需要忽略上一级路径使用-p1）
    [King@Fedora xxx]$ patch -p1 < xx.patch
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    222222
    [King@Fedora xxx]$ patch -RE < xxx.patch
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    111111
    
    //在当前路径打上上级路径的补丁（这里需要忽略上上一级路径使用-p2）
    [King@Fedora xxx]$ patch -p2 < x.patch
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    222222
    [King@Fedora xxx]$ patch -RE < x.patch
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    111111

--------------------

[King@Fedora xx]$ patch-p0 < xx.patch # 用第二个的 补丁 修改 第一个文件
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    222222
    [King@Fedora xxx]$ patch -RE < xxx.patch #用第一个的 补丁 修改 第一个文件
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    111111
    
    [King@Fedora xxx]$ patch -p1 < x.patch
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    222222
    [King@Fedora xxx]$ patch -RE < xxx.patch
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    111111

--------------------

[King@Fedora x]$ patch-p0< x.patch # 用第二个的 补丁 修改 第一个文件
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    222222
    [King@Fedora xxx]$ patch -RE < xxx.patch #用第一个的 补丁 修改 第一个文件
    patching file xxx1
    [King@Fedora xxx]$ cat xxx1
    111111
    111111

这里唯一需要说明的是p0的含义，因为在x.patch补丁文件里的路径信息是这样的：
        --- xx/xxx/xxx1
    p表示跳过几级目录，因为是在x目录下使用的patch命令，xx目录就在x目录下，所以不必跳过任何目录，而应该使用--- xx/xxx/xxx1完整路径，所以此时使用的是p0。
    
    注意：patch -p后面是不能带负数的。不使用p参数的时候，patch命令会忽略任何目录，直接使用文件。

[King@Fedora x]$ patch x/xx/xxx/xxx1 < x.patch # 用补丁x.patch直接修改文件xxx1，因为没有用p参数，所以会忽略掉补丁文件里的所有目录。

##### 实验 #####

# mkdir demo
    # cd demo

*  1、先模拟一个项目目录old：

# mkdir -p old/a/b
    # vi old/a/b/foo.txt
    old_line_1
    old_line_2

*  2、假设我们发现项目old有bug代码，下面我们先拷贝一个新目录new，并在此修改bug代码：

# cp -r old new
    # vi new/a/b/foo.txt
    new_line_1
    new_line_2

*  3、保证old和new两个目录都在当前目录下，下面就可以使用diff命令了（diff -Naur通常用这个就可以了），不要使用绝对路径，而应该使用相对路径：

# LC_ALL=C TZ=UTC0 diff -Naur old new > foo.patch
    如果不在意字符集，时差等问题，也可以省略LC_ALL=C TZ=UTC0环境变量：
    # diff -Naur old new > foo.patch

# cat foo.patch
    diff -Naur old/a/b/foo.txt new/a/b/foo.txt
    --- old/a/b/foo.txt  2009-12-07 20:40:07.000000000 +0800
    +++ new/a/b/foo.txt  2009-12-07 20:41:51.000000000 +0800
    @@ -1,2 +1,2 @@
    -old_line_1
    -old_line_2
    +new_line_1
    +new_line_2

*  此时的文件目录结构大概如下所示：

#tree
     demo
     |-- old
     | `-- a
     |  `-- b
     |   `-- foo.txt
     |-- new
     | `-- a
     |  `-- b
     |   `-- foo.txt 
    -- foo.patch

*  4、下面看看如何使用patch来应用补丁，要注意的是当前目录是demo，试试下面命令：

# patch -p0 < foo.patch
    patching file old/a/b/foo.txt

这里唯一需要说明的是p0的含义，因为在foo.patch补丁文件里的路径信息是这样的：
        --- old/a/b/foo.txt
    p表示跳过几级目录，因为是在demo目录下使用的patch命令，old目录就在demo目录下，所以不必跳过任何目录，而应该使用old/a/b/foo.txt完整路径，所以此时使用的是p0。

# cat old/a/b/foo.txt
    new_line_1
    new_line_2

*  此时如果你再次使用patch命令，系统会问你是否想还原，输入y还原：

# patch -p0 < foo.patch
     patching file old/a/b/foo.txt
     Reversed (or previously applied) patch detected! Assume -R? [n] y

查看一下目标文件，你会发现内容已经还原成旧的了：
    
    # cat old/a/b/foo.txt
    old_line_1
    old_line_2

*  如果你想严格指定是应用补丁 可以使用下面命令（就是增加N参数）：

# patch -Np0 < foo.patch

*  如果你想严格指定是 还原补丁 可以使用下面命令（就是增加R参数）：

# patch -Rp0 < foo.patch

*  5、改变一下当前路径：

# cd old
    //此时就应该是p1，而不是p0了，引用foo.patch文件的路径也要相对变一下，因为当前目录已经是old了
    # patch -p1 < ../foo.patch
    patching file a/b/foo.txt
    //因为此时我们是在old下使用patch命令，和a子目录平级，而补丁文件foo.patch里的路径声明是：
    --- old/a/b/foo.txt
    //也就是说第一个斜线左边的old/部分已经没用了，这就是p1的含义！

*  6、继续往深度变换路径，依次测试使用p2,p3参数：

# cd a
    
    # patch -p2 < ../../foo.patch
    patching file b/foo.txt
    
    # cd b
    
    # patch -p3 < ../../../foo.patch
    patching file foo.txt

*  在本例中，p3已经是最深目录了，此时可以省略p参数，也就是说，不使用p参数的时候，patch命令会忽略任何目录，直接使用文件。：

# patch < ../../../foo.patch
    patching file foo.txt

--------------------

*  转载至“脚本之家”

--------------------