Làm cách nào tôi có thể đặt lại hoặc hoàn nguyên tệp thành một bản sửa đổi cụ thể?

Tôi đã thực hiện một số thay đổi đối với một tệp đã được cam kết một vài lần như là một phần của một nhóm các tệp, nhưng bây giờ muốn đặt lại / hoàn nguyên các thay đổi trên đó trở lại phiên bản trước.

Tôi đã thực hiện git logcùng với git diffviệc tìm bản sửa đổi mà tôi cần, nhưng tôi không biết làm thế nào để đưa tập tin trở lại trạng thái cũ trong quá khứ.

Giả sử hàm băm của cam kết bạn muốn là c5f567:

git checkout c5f567 -- file1/to/restore file2/to/restore

Các git checkout trang người đàn ông mang lại cho biết thêm thông tin.

Nếu bạn muốn hoàn nguyên về cam kết trước đó c5f567, hãy thêm vào ~1(trong đó 1 là số lần xác nhận bạn muốn quay lại, đó có thể là bất cứ điều gì):

git checkout c5f567~1 -- file1/to/restore file2/to/restore

Một lưu ý phụ, tôi luôn cảm thấy khó chịu với lệnh này vì nó được sử dụng cho cả những thứ thông thường (thay đổi giữa các nhánh) và những thứ khác thường, phá hoại (loại bỏ những thay đổi trong thư mục làm việc).

Bạn có thể nhanh chóng xem lại các thay đổi được thực hiện đối với tệp bằng lệnh diff:

git diff <commit hash> <filename>

Sau đó, để hoàn nguyên một tệp cụ thể cho cam kết đó, hãy sử dụng lệnh đặt lại:

git reset <commit hash> <filename>

Bạn có thể cần phải sử dụng --hardtùy chọn nếu bạn có sửa đổi cục bộ.

Một quy trình công việc tốt để quản lý các điểm mốc là sử dụng các thẻ để đánh dấu sạch các điểm trong dòng thời gian của bạn. Tôi hoàn toàn không thể hiểu câu cuối cùng của bạn nhưng điều bạn có thể muốn là phân nhánh một nhánh từ thời điểm trước đó. Để làm điều này, sử dụng lệnh kiểm tra tiện dụng:

git checkout <commit hash>
git checkout -b <new branch name>

Sau đó, bạn có thể khởi động lại theo dòng chính của mình khi bạn sẵn sàng hợp nhất những thay đổi đó:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Bạn có thể sử dụng bất kỳ tham chiếu nào đến cam kết git, bao gồm SHA-1 nếu thuận tiện nhất. Vấn đề là lệnh này trông như thế này:

git checkout [commit-ref] -- [filename]

git checkout -- foo

Điều đó sẽ thiết lập lại foothành CHÍNH. Bạn cũng có thể:

git checkout HEAD^ foo

cho một sửa đổi trở lại, vv

Và để trở lại phiên bản cam kết cuối cùng, thường xuyên nhất, bạn có thể sử dụng lệnh đơn giản hơn này.

git checkout HEAD file/to/restore

Tôi đã có cùng một vấn đề ngay bây giờ và tôi thấy câu trả lời này dễ hiểu nhất ( commit-reflà giá trị SHA của thay đổi trong nhật ký bạn muốn quay lại):

git checkout [commit-ref] [filename]

Điều này sẽ đưa phiên bản cũ đó vào thư mục làm việc của bạn và từ đó bạn có thể cam kết nó nếu bạn muốn.

Nếu bạn biết bạn cần quay lại bao nhiêu lần, bạn có thể sử dụng:

git checkout master~5 image.png

Điều này giả định rằng bạn đang ở masterchi nhánh và phiên bản bạn muốn là 5 cam kết trở lại.

Tôi nghĩ rằng tôi đã tìm thấy nó .... từ http://www-cs-students.stanford.edu/~blynn/gitmagic/ch02.html

Đôi khi bạn chỉ muốn quay lại và quên đi mọi thay đổi đã qua một điểm nhất định vì tất cả đều sai.

Bắt đầu với:

$ git log

trong đó hiển thị cho bạn một danh sách các cam kết gần đây và băm SHA1 của chúng.

Tiếp theo, gõ:

$ git reset --hard SHA1_HASH

để khôi phục trạng thái cho một cam kết nhất định và xóa tất cả các cam kết mới hơn khỏi bản ghi vĩnh viễn.

Điều này làm việc cho tôi:

git checkout <commit hash> file

Sau đó cam kết thay đổi:

git commit -a

Bạn phải cẩn thận khi nói "rollback". Nếu bạn đã từng có một phiên bản của tệp trong cam kết $ A, và sau đó thực hiện hai thay đổi trong hai cam kết riêng biệt $ B và $ C (vì vậy những gì bạn đang thấy là lần lặp thứ ba của tệp) và nếu bạn nói " Tôi muốn quay trở lại cái đầu tiên ", bạn có thực sự muốn nói điều đó không?

Nếu bạn muốn loại bỏ các thay đổi cả lần lặp thứ hai và lần thứ ba, thì rất đơn giản:

$ git checkout $A file

và sau đó bạn cam kết kết quả. Lệnh hỏi "Tôi muốn kiểm tra tệp từ trạng thái được ghi bởi cam kết $ A".

Mặt khác, điều bạn muốn nói là loại bỏ thay đổi lần lặp thứ hai (tức là cam kết $ B) được đưa vào, trong khi vẫn giữ những gì cam kết $ C đã làm với tệp, bạn sẽ muốn hoàn nguyên $ B

$ git revert $B

Lưu ý rằng bất kỳ ai đã tạo cam kết $ B có thể không bị kỷ luật nhiều và có thể đã cam kết thay đổi hoàn toàn không liên quan trong cùng một cam kết và việc hoàn nguyên này có thể chạm vào các tệp khác với tệp bạn thấy các thay đổi vi phạm, vì vậy bạn có thể muốn kiểm tra kết quả cẩn thận sau khi thực hiện vì thế.

Thật thú vị, git checkout foosẽ không hoạt động nếu bản sao làm việc nằm trong một thư mục có tên foo; tuy nhiên, cả hai git checkout HEAD foovà git checkout ./foosẽ:

$ pwd
/Users/aaron/Documents/work/foo
$ git checkout foo
D   foo
Already on "foo"
$ git checkout ./foo
$ git checkout HEAD foo

Đây là cách rebasehoạt động:

git checkout <my branch>
git rebase master
git checkout master
git merge <my branch>

Giả sử bạn có

---o----o----o----o  master
    \---A----B       <my branch>

Hai lệnh đầu tiên ... cam kết kiểm tra git git rebase master

... kiểm tra chi nhánh thay đổi bạn muốn áp dụng cho masterchi nhánh. Các rebaselệnh có các cam kết từ <my branch>(không được tìm thấy trong master) và reapplies họ người đứng đầu master. Nói cách khác, cha mẹ của cam kết đầu tiên <my branch>không còn là một cam kết trước đó trong masterlịch sử, mà là người đứng đầu hiện tại master. Hai lệnh giống như:

git rebase master <my branch>

Có thể dễ dàng hơn để nhớ lệnh này vì cả hai nhánh "cơ sở" và "sửa đổi" đều rõ ràng.

. Kết quả lịch sử cuối cùng là:

---o----o----o----o   master
                   \----A'----B'  <my branch>

Hai lệnh cuối cùng ...

git checkout master
git merge <my branch>

... thực hiện hợp nhất chuyển tiếp nhanh để áp dụng tất cả các <my branch>thay đổi vào master. Không có bước này, cam kết rebase sẽ không được thêm vào master. Kết quả cuối cùng là:

---o----o----o----o----A'----B'  master, <my branch>

mastervà <my branch>cả tài liệu tham khảo B'. Ngoài ra, từ thời điểm này, an toàn để xóa <my branch>tham chiếu.

git branch -d <my branch>

Kể từ git v2.23.0, có một phương pháp khôi phục git mới được cho là đảm nhận một phần git checkouttrách nhiệm (ngay cả câu trả lời được chấp nhận git checkoutcũng khá khó hiểu). Xem những điểm nổi bật của những thay đổi trên blog github .

Hành vi mặc định của lệnh này là khôi phục trạng thái của cây làm việc với nội dung đến từ sourcetham số (trong trường hợp của bạn sẽ là hàm băm cam kết).

Vì vậy, dựa trên câu trả lời của Greg Hewgill (giả sử hàm băm cam kết c5f567), lệnh sẽ giống như sau:

git restore --source=c5f567 file1/to/restore file2/to/restore

Hoặc nếu bạn muốn khôi phục lại nội dung của một cam kết trước c5f567:

git restore --source=c5f567~1 file1/to/restore file2/to/restore

Đầu đặt lại đầu tiên cho tệp mục tiêu

git reset HEAD path_to_file

Kiểm tra lần thứ hai tập tin đó

git checkout -- path_to_file

git-aliases, awk và shell-function để giải cứu!

git prevision <N> <filename>

trong đó <N>số lượng bản sửa đổi của tệp để khôi phục cho tệp <filename>.
Ví dụ: để kiểm tra bản sửa đổi trước đó ngay lập tức của một tệp x/y/z.c, hãy chạy

git prevision -1 x/y/z.c

Làm thế nào git thịnh hành hoạt động?

Thêm phần sau vào gitconfig

[alias]
        prevision = "!f() { git checkout `git log --oneline $2 |  awk -v commit="$1" 'FNR == -commit+1 {print $1}'` $2;} ;f"

Lệnh cơ bản

• thực hiện một git logtập tin được chỉ định và
• chọn id xác nhận thích hợp trong lịch sử của tệp và
• thực thi a git checkoutđến id xác thực cho tệp đã chỉ định.

Về cơ bản, tất cả những gì người ta sẽ làm thủ công trong tình huống này,
được gói gọn trong một bí danh git-alias đẹp, hiệu quả - git-thịnh hành

Tôi phải cắm EasyGit ở đây, đây là một trình bao bọc để giúp git dễ tiếp cận hơn với người mới mà không gây nhầm lẫn cho người dùng dày dạn kinh nghiệm. Một trong những điều nó làm là mang lại nhiều ý nghĩa hơngit revert . Trong trường hợp này, bạn chỉ cần nói:

eg revert foo/bar foo/baz

Trong trường hợp bạn muốn hoàn nguyên tệp về một cam kết trước đó (và tệp bạn muốn hoàn nguyên đã cam kết), bạn có thể sử dụng

git checkout HEAD^1 path/to/file

hoặc là

git checkout HEAD~1 path/to/file

Sau đó, chỉ cần giai đoạn và cam kết phiên bản "mới".

Được trang bị kiến ​​thức rằng một cam kết có thể có hai cha mẹ trong trường hợp hợp nhất, bạn nên biết rằng CHÍNH ^ 1 là cha mẹ đầu tiên và CHÍNH ~ 1 là cha mẹ thứ hai.

Hoặc sẽ hoạt động nếu chỉ có một cha mẹ trong cây.

Nhiều đề xuất ở đây, hầu hết dọc theo dòng git checkout $revision -- $file. Một vài lựa chọn thay thế tối nghĩa:

git show $revision:$file > $file

Ngoài ra, tôi sử dụng điều này rất nhiều chỉ để xem một phiên bản cụ thể tạm thời:

git show $revision:$file

hoặc là

git show $revision:$file | vim -R -

(OBS: $filecần phải được thêm tiền tố ./nếu đó là đường dẫn tương đối git show $revision:$fileđể làm việc)

Và điều kỳ lạ hơn nữa:

git archive $revision $file | tar -x0 > $file

Lưu ý, tuy nhiên, điều đó git checkout ./foovà git checkout HEAD ./foo không hoàn toàn giống nhau; trường hợp tại điểm:

$ echo A > foo
$ git add foo
$ git commit -m 'A' foo
Created commit a1f085f: A
1 files changed, 1 insertions(+), 0 deletions(-)
create mode 100644 foo
$ echo B >> foo
$ git add foo
$ echo C >> foo
$ cat foo
A
B
C
$ git checkout ./foo
$ cat foo
A
B
$ git checkout HEAD ./foo
$ cat foo
A

( addGiai đoạn thứ hai tệp trong chỉ mục, nhưng nó không được cam kết.)

Git checkout ./foocó nghĩa là đường dẫn hoàn nguyên ./footừ chỉ mục ; việc thêm HEADhướng dẫn Git hoàn nguyên đường dẫn đó trong chỉ mục để HEADsửa đổi trước khi thực hiện.

Đối với tôi không có câu trả lời nào có vẻ thực sự rõ ràng và do đó tôi muốn thêm câu trả lời của tôi có vẻ siêu dễ dàng.

Tôi có một cam kết abc1và sau đó tôi đã thực hiện một vài (hoặc một sửa đổi) cho một tệp file.txt.

Bây giờ hãy nói rằng tôi đã làm hỏng một cái gì đó trong tệp file.txtvà tôi muốn quay lại cam kết trước đó abc1.

1 . git checkout file.txt: điều này sẽ loại bỏ các thay đổi cục bộ, nếu bạn không cần chúng

2 . git checkout abc1 file.txt: điều này sẽ đưa tập tin của bạn đến phiên bản mong muốn của bạn

3 . git commit -m "Restored file.txt to version abc1": điều này sẽ cam kết sự đảo ngược của bạn.

4. git push : điều này sẽ đẩy mọi thứ trên kho lưu trữ từ xa

Giữa bước 2 và 3 tất nhiên bạn có thể làm git statusđể hiểu chuyện gì đang xảy ra. Thông thường bạn sẽ thấy file.txtđã được thêm vào và đó là lý do tại sao không cần a git add.

1. Git hoàn nguyên tệp cho một cam kết cụ thể

git checkout Last_Stable_commit_Number -- fileName

2.Git hoàn nguyên tập tin đến một chi nhánh cụ thể

git checkout branchName_Which_Has_stable_Commit fileName

Để chuyển đến phiên bản cam kết trước đó của tệp, hãy lấy số cam kết, giả sử eb917a1 sau đó

git checkout eb917a1 YourFileName

Nếu bạn chỉ cần quay lại phiên bản được cam kết cuối cùng

git reset HEAD YourFileName
git checkout YourFileName

Điều này chỉ đơn giản sẽ đưa bạn đến trạng thái cam kết cuối cùng của tệp

kiểm tra git ref | commitHash - filePath

ví dụ

git checkout HEAD~5 -- foo.bar
or 
git checkout 048ee28 -- foo.bar

Nhiều câu trả lời ở đây tuyên bố sẽ sử dụng git reset ... <file>hoặc git checkout ... <file>bằng cách làm như vậy, bạn sẽ mất mọi sửa đổi đối với <file>cam kết sau khi cam kết bạn muốn hoàn nguyên.

Nếu bạn muốn hoàn nguyên các thay đổi từ một cam kết trên một tệp duy nhất, giống như git revertthực hiện nhưng chỉ với một tệp (hoặc nói một tập hợp con của các tệp cam kết), tôi khuyên bạn nên sử dụng cả hai git diffvà git applynhư thế (với <sha>= hàm băm của cam kết bạn muốn hoàn nguyên):

git diff <sha>^ <sha> path/to/file.ext | git apply -R

Về cơ bản, trước tiên, nó sẽ tạo ra một bản vá tương ứng với những thay đổi bạn muốn hoàn nguyên, sau đó áp dụng ngược lại bản vá để loại bỏ những thay đổi đó.

Tất nhiên, nó sẽ không hoạt động nếu các dòng hoàn nguyên đã được sửa đổi bởi bất kỳ cam kết nào giữa <sha1>và HEAD(xung đột).

Sử dụng git logđể lấy khóa băm cho phiên bản cụ thể và sau đó sử dụnggit checkout <hashkey>

Lưu ý: Đừng quên gõ băm trước cái cuối cùng. Hàm băm cuối cùng chỉ vị trí hiện tại của bạn (CHÍNH) và không thay đổi gì.

Rõ ràng ai đó cần phải viết một cuốn sách dễ hiểu về git, hoặc git cần được giải thích rõ hơn trong tài liệu. Đối mặt với vấn đề tương tự tôi đoán rằng

cd <working copy>
git revert master

sẽ hoàn tác cam kết cuối cùng dường như sẽ làm.

Ian

Bạn có thể làm điều đó trong 4 bước:

1. hoàn nguyên toàn bộ cam kết với tệp bạn muốn hoàn nguyên cụ thể - nó sẽ tạo ra một cam kết mới trên nhánh của bạn
2. thiết lập lại cam kết đó - loại bỏ cam kết và di chuyển các thay đổi đến khu vực làm việc
3. chọn các tệp để hoàn nguyên và cam kết chúng
4. thả tất cả các tập tin khác trong khu vực làm việc của bạn

Những gì bạn cần nhập vào thiết bị đầu cuối của bạn :

1. git revert <commit_hash>
2. git reset HEAD~1
3. git add <file_i_want_to_revert> && git commit -m 'reverting file'
4. git checkout .

chúc may mắn

Đây là một bước rất đơn giản. Kiểm tra tệp vào id xác nhận mà chúng tôi muốn, ở đây một id xác nhận trước đó, sau đó chỉ cần git commit sửa đổi và chúng tôi đã hoàn tất.

# git checkout <previous commit_id> <file_name>
# git commit --amend

Điều này rất tiện dụng. Nếu chúng tôi muốn đưa bất kỳ tệp nào vào bất kỳ id xác nhận trước nào ở đầu cam kết, chúng tôi có thể dễ dàng thực hiện.

git revert <hash>

Sẽ hoàn nguyên một cam kết nhất định. Có vẻ như bạn nghĩ git revertchỉ ảnh hưởng đến cam kết gần đây nhất.

Điều đó không giải quyết được vấn đề của bạn, nếu bạn muốn hoàn nguyên một thay đổi trong một tệp cụ thể và cam kết đó đã thay đổi nhiều hơn tệp đó.

nếu bạn cam kết một tệp sai trong lần xác nhận cuối cùng của mình, hãy làm theo hướng dẫn:

1. cây nguồn mở, thay đổi cam kết này

2. thay đổi các dòng và tìm cam kết của bạn rằng tệp sai được gửi dưới dạng cam kết

3. bạn có thể xem danh sách các thay đổi của bạn trong cam kết đó
4. chọn nó và sau đó nhấp vào ... nút bên phải ... nhấp vào tập tin đảo ngược
5. sau đó bạn có thể thấy nó trên tab trạng thái tệp ở phía dưới bên trái, sau đó nhấp vào unstage:

6. mở mã phòng thu trực quan của bạn và hoàn nguyên lại bằng cách cam kết các tệp đã xóa của bạn
7. sau tất cả, bạn có thể thấy kết quả trong lần xác nhận cuối cùng của mình trong cây nguồn