获取当前修改文件的 git patch

Question

As a noob in git, i have no idea how to have patch to current modified files relative to original ones, ie the first git clone. Anyone experienced expert on this developmental software versioning, mainly patch and diff for working as collaborator (in fork, PR, etc) so that explain the correct way ?

Answer 1

Making a patch

You can create a patch that represents all your uncommitted changes simply by saving the output of git diff to a file:

git diff > my-changes.patch

This patch is just a file, and so you could email it to someone or save it on a thumb drive or do whatever else you wanted to with it (I'm not sure why you'd need to do this, but you can)

Then, the patch can be applied via

git apply my-changes.patch

You typically don't need to make patches manually, and when you do need to make patches, they should always be from pre-existing commits.

A patch can be made from pre-existing commits like so:

git diff <start commit>..HEAD > my-changes.patch

This will create a patch of all changes since <start commit> . You can also specify <start commit> as a branch, a tag (which refers to a specific commit), or something specific like main~10 (which would mean the main branch, 10 commits ago).

# Get a patch of all changes that haven't been pushed
git diff origin/main..main > local-changes.patch

# Get a patch of all changes on feature-branch
git diff main..feature-branch > changes-on-feature-branch.patch

# Get the last 10 commits as a patch
git diff main~10..main > last-10-commits.patch

# Get all the changes since a particular tag
git diff v1.0.0..main > changes-since-v1.0.0.patch

ONCE AGAIN, YOU TYPICALLY DO NOT NEED TO CREATE PATCHES MANUALLY!!! As a tool, git diff is really useful for exploring history, seeing current changes, seeing changes that will get merged, or a million other uses. It outputs stuff in a form that can be directly applied with git apply , but I haven't had to manually send someone a patch at any point in my entire life.

Collaborating in git, the right way

There are three typical ways to collaborate, which I'll list from easiest to most advanced.

Method 1: Multiple collaborators, who all have access

This is the most typical situation you'll see in school, or in most work environments. Everyone can push code to the same repository.

Once you have a copy of the repo on your machine, the workflow looks like this:

• Make changes or updates to the code

• Commit your changes: git add <your changes> && git commit

  You can make as many commits as you want before uploading. The best thing to do is make small commits every time you finish an important piece of code, like a function, or a class.

• Download remote changes: git pull

  If your partners or coworkers have updated the repository with changes, you have to do this before pushing. This allows you to check to make sure that your changes work with their changes.

• Upload your changes: git push

Method 2: you're working on someone else's open source project

You won't always be able to push your changes directly. For example, if you're working on an open source project, you'll typically submit changes for review, and the maintainers will be the ones to merge them.

This is typically done by forking the project, making changes, uploading your changes to your repository (the forked version), and then submitting a pull request to integrate your changes back into the original project.

It looks like this:

• Fork (on github, gitlab, or another service
• Clone the forked version onto your local machine
• Make changes
• Commit your changes
• Push your changes
• Create a pull request to merge your changes back in (You can do this on github, gitlab, or wherever you forked the repo)

Method 3: Email your commits as a patch

This method is typically used for larger, older open-source projects, that don't want to rely on a centralized service like github or gitlab.

It's done by using git send-email to email the patches directly from the command line. Git will create a patch for you automatically. All you have to do is specify the range of commits you want to send as a patch.

For example, if you made your changes on a local branch called dev , then you would use it like this:

git send-email --compose --from=<your email> --to=<their email> master..dev

Here, master..dev is the range of patches you're sending. It's all the patches on the dev branch, that aren't on the master branch. AKA, your changes.

This command will open a text editor where you can write the body of your email, and git will attach the patch to the email, and send it.

Note that you have to configure your email to work with git send-email. Beginners will not typically need to do this.