Go to particular revision_问答_开发者_运维开发者技术经验分享

I cloned a git repository of a certain project. Can I turn the files to the 开发者_JAVA百科initial state and when I review the files go to revision 2, 3, 4 ... most recent? I'd like to have an overview of how the project was evolving.

Before executing this command keep in mind that it will leave you in detached head status

Use git checkout <sha1> to check out a particular commit.

Where <sha1> is the commit unique number that you can obtain with git log

Here are some options after you are in detached head status:

Copy the files or make the changes that you need to a folder outside your git folder, checkout the branch were you need them git checkout <existingBranch> and replace files
Create a new local branch git checkout -b <new_branch_name> <sha1>

Note: to "undo" (return from) the detached head state simply use:

git checkout <branch> (where <branch> is e.g. master).

To go to a particular version/commit run following commands. HASH-CODE you can get from git log --oneline -n 10

git reset --hard HASH-CODE

Note - After reset to particular version/commit you can run git pull --rebase, if you want to bring back all the commits which are discarded.

You can get a graphical view of the project history with tools like gitk. Just run:

gitk --all

If you want to checkout a specific branch:

git checkout <branch name>

For a specific commit, use the SHA1 hash instead of the branch name. (See Treeishes in the Git Community Book, which is a good read, to see other options for navigating your tree.)

git log has a whole set of options to display detailed or summary history too.

I don't know of an easy way to move forward in a commit history. Projects with a linear history are probably not all that common. The idea of a "revision" like you'd have with SVN or CVS doesn't map all that well in Git.

Using a commit's SHA1 key, you could do the following:

First, find the commit you want for a specific file:

git log -n <# commits> <file-name>

This, based on your <# commits>, will generate a list of commits for a specific file.

TIP: if you aren't sure what commit you are looking for, a good way to find out is using the following command: git diff <commit-SHA1>..HEAD <file-name>. This command will show the difference between the current version of a commit, and a previous version of a commit for a specific file.

NOTE: a commit's SHA1 key is formatted in the git log -n's list as:

commit <SHA1 id>

Second, checkout the desired version:

If you have found the desired commit/version you want, simply use the command: git checkout <desired-SHA1> <file-name>

This will place the version of the file you specified in the staging area. To take it out of the staging area simply use the command: reset HEAD <file-name>

To revert back to where the remote repository is pointed to, simply use the command: git checkout HEAD <file-name>

To get to a specific committed code, you need the hash code of that commit. You can get that hash code in two ways:

Get it from your github/gitlab/bitbucket account. (It's on your commit url, i.e: github.com/user/my_project/commit/commit_hash_code), or you can
git log and check your recent commits on that branch. It will show you the hash code of your commit and the message you leaved while you were committing your code. Just copy and then do git checkout commit_hash_code

After moving to that code, if you want to work on it and make changes, you should make another branch with git checkout -b <new-branch-name>, otherwise, the changes will not be retained.

I was in a situation where we have a master branch, and then another branch called 17.0 and inside this 17.0 there was a commit hash no say "XYZ". And customer is given a build till that XYZ revision. Now we came across a bug and that needs to be solved for that customer. So we need to create separate branch for that customer till that "xyz" hash. So here is how I did it.

First I created a folder with that customer name on my local machine. Say customer name is "AAA" once that folder is created issue following command inside this folder:

git init
git clone After this command you will be on master branch. So switch to desired branch
git checkout 17.0 This will bring you to the branch where your commit is present
git checkout This will take your repository till that hash commit. See the name of ur branch it got changed to that commit hash no. Now give a branch name to this hash
git branch ABC This will create a new branch on your local machine.
git checkout ABC
git push origin ABC This will push this branch to remote repository and create a branch on git server. You are done.

One way would be to create all commits ever made to patches. checkout the initial commit and then apply the patches in order after reading.

use git format-patch <initial revision> and then git checkout <initial revision>. you should get a pile of files in your director starting with four digits which are the patches.

when you are done reading your revision just do git apply <filename> which should look like git apply 0001-* and count.

But I really wonder why you wouldn't just want to read the patches itself instead? Please post this in your comments because I'm curious.

the git manual also gives me this:

git show next~10:Documentation/README
Shows the contents of the file Documentation/README as they were current in the 10th last commit of the branch next.

you could also have a look at git blame filename which gives you a listing where each line is associated with a commit hash + author.