Create a git patch from the changes in the current working directory

问题

Say I have uncommitted changes in my working directory. How can I make a patch from those without having to create a commit?

回答1:

git diff for unstaged changes. git diff --cached for staged changes.

回答2:

If you haven't yet commited the changes, then:

git diff > mypatch.patch

But sometimes it happens that part of the stuff you're doing are new files that are untracked and won't be in your git diff output. So, one way to do a patch is to stage everything for a new commit (git add each file, or just git add .) but don't do the commit, and then:

git diff --cached > mypatch.patch

Add the 'binary' option if you want to add binary files to the patch (e.g. mp3 files):

git diff --cached --binary > mypatch.patch

You can later apply the patch:

git apply mypatch.patch

Note: You can also use --staged as a synonym of --cached.

回答3:

git diff and git apply will work for text files, but won't work for binary files.

You can easily create a full binary patch, but you will have to create a temporary commit. Once you've made your temporary commit(s), you can create the patch with:

git format-patch <options...>

After you've made the patch, run this command:

git reset --mixed <SHA of commit *before* your working-changes commit(s)>

This will roll back your temporary commit(s). The final result leaves your working copy (intentionally) dirty with the same changes you originally had.

On the receiving side, you can use the same trick to apply the changes to the working copy, without having the commit history. Simply apply the patch(es), and git reset --mixed <SHA of commit *before* the patches>.

Note that you might have to be well-synced for this whole option to work. I've seen some errors when applying patches when the person making them hadn't pulled down as many changes as I had. There are probably ways to get it to work, but I haven't looked far into it.

---

Here's how to create the same patches in Tortoise Git (not that I recommend using that tool):

1. Commit your working changes
2. Right click the branch root directory and click Tortoise Git -> Create Patch Serial
   1. Choose whichever range makes sense (Since: FETCH_HEAD will work if you're well-synced)
   2. Create the patch(es)
3. Right click the branch root directory and click Tortise Git -> Show Log
4. Right click the commit before your temporary commit(s), and click reset "<branch>" to this...
5. Select the Mixed option

And how to apply them:

1. Right click the branch root directory and click Tortoise Git -> Apply Patch Serial
2. Select the correct patch(es) and apply them
3. Right click the branch root directory and click Tortise Git -> Show Log
4. Right click the commit before the patch's commit(s), and click reset "<branch>" to this...
5. Select the Mixed option

回答4:

To create a patch with both modified & new files (staged) you can run:

git diff HEAD > file_name.patch

回答5:

I like:

git format-patch HEAD~<N>

where <N> is number of last commits to save as patches.

The details how to use the command are in the DOC

UPD
Here you can find how to apply them then.

UPD For those who did not get the idea of format-patch
Add alias:

git config --global alias.make-patch '!bash -c "cd ${GIT_PREFIX};git add .;git commit -m ''uncommited''; git format-patch HEAD~1; git reset HEAD~1"'

Then at any directory of your project repository run:

git make-patch

This command will create 0001-uncommited.patch at your current directory. Patch will contain all the changes and untracked files that are visible to next command:

git status .

回答6:

If you want to do binary, give a --binary option when you run git diff.

来源：https://stackoverflow.com/questions/5159185/create-a-git-patch-from-the-changes-in-the-current-working-directory