어떻게하면 Git에서 가장 최근의 로컬 커밋을 실행 취소 할 수 있습니까?

커밋 실행을 모르면 커밋을 취소하는 것이 약간 두려운 일입니다. 그러나 당신이 이해하면 실제로 놀랍습니다.

이것을 가지고 있다고 가정하십시오. 여기서 C는 HEAD이고 (F)는 파일의 상태입니다.

   (F)
A-B-C
    ↑
  master

nuke commit C 및 다시는 보지 않음을 원합니다. 당신은 이것을합니다 :

git reset --hard HEAD~1

결과는 다음과 같습니다.

 (F)
A-B
  ↑
master

이제 B는 머리입니다. --hard을 (를) 사용했기 때문에 파일은 커밋 B에서 해당 상태로 재설정됩니다.

아, 그러나 커밋 C가 재앙이 아니라 조금만 가정했다고 가정 해보십시오. 더 나은 커밋을 수행하기 전에 약간의 편집을 위해 커밋을 실행 취소하지만 변경 사항을 유지하고 싶습니다. C를 HEAD로 사용하여 여기부터 다시 시작하십시오.

   (F)
A-B-C
    ↑
  master

--hard을 (를) 제외하고이 작업을 수행 할 수 있습니다.

git reset HEAD~1

이 경우 결과는 다음과 같습니다.

   (F)
A-B-C
  ↑
master

두 경우 모두 HEAD는 최신 커밋에 대한 포인터 일뿐입니다. git reset HEAD~1를 수행하면 Git에게 HEAD 포인터를 한 커밋 뒤로 이동하도록 지시합니다. 그러나 (--hard를 사용하지 않는 한) 파일을 그대로 둡니다. 이제 git status은 (는) C에 체크인 한 변경 사항을 보여줍니다. 잃어버린 것은 없습니다!

가장 가볍게 터치하려면 커밋을 취소하지만 파일과 index를 남겨 둘 수도 있습니다.

git reset --soft HEAD~1

이렇게하면 파일 만 남게 될뿐만 아니라 index 그대로 남습니다. git status을 수행하면 이전과 동일한 파일이 색인에 있음을 알 수 있습니다. 실제로이 명령 바로 뒤에 git commit을 수행하면 방금 수행 한 동일한 커밋을 다시 실행할 수 있습니다.

한 가지 더 : 첫 번째 예에서와 같이 커밋을 삭제한다고 가정_ 하지만 결국 필요하다는 것을 발견하십시오? 힘든 운 이지요?

아니요, still 다시 가져올 수있는 방법이 있습니다. git reflog를 입력하면 이동 한 (부분) commit shas (즉, 해시) 목록이 표시됩니다. 파괴 한 커밋을 찾아서 다음과 같이하십시오.

git checkout -b someNewBranchName shaYouDestroyed

이제 커밋을 부활 시켰습니다. 커밋은 실제로 90 일 동안 Git에서 파괴되지 않으므로 일반적으로 돌아 가려고하지 않은 것을 구할 수 있습니다.

알아내는 데 시간이 좀 걸렸으니 어쩌면이게 누군가를 도울 것입니다 ...

이미 커밋을 공개 (원격 저장소로 푸시)했는지 여부에 따라 마지막 커밋을 "실행 취소"하는 두 가지 방법이 있습니다.

로컬 커밋을 실행 취소하는 방법

로컬로 커밋했는데 이제는 커밋을 제거하려고한다고 가정 해 보겠습니다.

git log
    commit 101: bad commit    # latest commit, this would be called 'HEAD'
    commit 100: good commit   # second to last commit, this is the one we want

모든 커밋을 마지막 커밋 이전의 상태로 복원하려면 reset 전에 커밋에 HEAD을해야합니다.

git reset --soft HEAD^     # use --soft if you want to keep your changes
git reset --hard HEAD^     # use --hard if you don't care about keeping the changes you made

이제 git log는 마지막 커밋이 제거되었음을 보여줍니다.

공개 커밋을 실행 취소하는 방법

커밋을 이미 공개 한 경우 이전 커밋 (현재 HEAD)에서 변경 한 내용을 "되돌릴"새 커밋을 만들 수 있습니다.

git revert HEAD

변경 사항이 되돌려 져서 커밋 할 준비가되었습니다.

git commit -m 'restoring the file I removed by accident'
git log
    commit 102: restoring the file I removed by accident
    commit 101: removing a file we don't need
    commit 100: adding a file that we need

더 자세한 정보는 Git Basics - Undoing Things

원하는 방식대로 파일을 추가/제거하십시오.

git rm classdir
git add sourcedir

그런 다음 커밋을 수정하십시오.

git commit --amend

이전의 잘못된 커밋은 새 인덱스 상태를 반영하도록 편집됩니다. 즉, 처음에는 실수를하지 않은 것처럼 보입니다.

아직 푸시하지 않은 경우에만이 작업을 수행해야합니다. 푸시했으면 정상적으로 수정해야합니다.

git rm yourfiles/*.class
git commit -a -m "deleted all class files in folder 'yourfiles'"

또는

git reset --hard HEAD~1

경고 : 위의 명령은 커밋하고자하는 .Java 파일 (및 다른 파일)에 대한 수정 사항을 영구적으로 제거합니다.

hard reset ~ HEAD-1는 커밋을 잘못하기 전에 작업 복사본을 커밋의 상태로 설정합니다.

마지막 커밋을 변경하려면

색인에서 파일을 바꾸십시오.

git rm --cached *.class
git add *.Java

그런 다음 개인 브랜치 인 경우 커밋을 amend 합니다.

git commit --amend

또는 공유 브랜치 인 경우 새 커밋을 만듭니다.

git commit -m 'Replace .class files with .Java files'

( 이전 커밋을 변경하려면 , 멋진 interactive rebase )

ProTip ™ : *.class를 gitignore 에 추가하면이 문제가 다시 발생하지 않습니다.

커밋을 되돌리려면

마지막 커밋을 변경해야하는 경우 커밋을 수정하는 것이 이상적인 솔루션이지만보다 일반적인 솔루션은 reset입니다.

다음을 사용하여 커밋으로 git을 재설정 할 수 있습니다.

git reset @~N

여기서 N은 HEAD 이전의 커밋 수이고 @~은 이전 커밋으로 재설정됩니다.

따라서 커밋을 수정하는 대신 다음을 사용할 수 있습니다.

git reset @~
git add *.Java
git commit -m "Add .Java files"

git help reset, 특히 --soft--mixed 및 --hard의 섹션을 확인하여 이것이 무엇을하는지 더 잘 이해하십시오.

Reflog

엉망인 경우 언제든지 reflog를 사용하여 삭제 된 커밋을 찾을 수 있습니다.

$ git reset @~
$ git reflog
c4f708b [email protected]{0}: reset: moving to @~
2c52489 [email protected]{1}: commit: added some .class files
$ git reset 2c52489
... and you're back where you started

git revert <commit-id> 사용

커밋 ID를 얻으려면 git log를 사용하십시오.

로컬 커밋을 완전히 취소 할 계획이라면, 커밋에서 변경 한 내용이 무엇이든, 그리고 그것에 대해 걱정하지 않는다면 다음 명령을 수행하십시오.

git reset --hard HEAD^1

(이 명령은 전체 커밋을 무시하고 변경 사항은 로컬 작업 트리에서 완전히 손실됩니다). 커밋을 취소하고 싶지만 (git add 후에 커밋하기 전에) 스테이징 영역에서 변경을 원할 경우 다음 명령을 수행하십시오.

git reset --soft HEAD^1

이제 커밋 된 파일이 준비 영역으로 들어옵니다. 잘못된 내용을 편집해야하기 때문에 파일을 업 스테이지하려는 경우 다음 명령을 실행하십시오

git reset HEAD

이제 커미트 된 파일을 무대 영역으로 가져 왔습니다. 이제 파일을 편집 할 준비가되었습니다. 따라서 변경 한 내용을 편집하고 추가하고 새롭고 새로운 커밋을하고 싶습니다.

기타

Git Extras installed가 있으면 git undo를 실행하여 최신 커밋을 실행 취소 할 수 있습니다. git undo 3는 마지막 3 개의 커밋을 실행 취소합니다.

공유 저장소에서 가장 최근에 수행 된 5 개의 커밋을 실행 취소하고 싶었습니다. 내가 롤백하고 싶은 리비전 ID를 찾았습니다. 그런 다음 다음을 입력했습니다.

Prompt> git reset --hard 5a7404742c85
HEAD is now at 5a74047 Added one more page to catalogue
Prompt> git Push Origin master --force
Total 0 (delta 0), reused 0 (delta 0)
remote: bb/acl: neoneye is allowed. accepted payload.
To [email protected]:thecompany/prometheus.git
 + 09a6480...5a74047 master -> master (forced update)
Prompt>

이전 로컬 커밋을 수정하는 방법

Git-gui (또는 이와 유사한)를 사용하여 git commit --amend를 수행하십시오. GUI에서 커밋에서 개별 파일을 추가하거나 제거 할 수 있습니다. 커밋 메시지를 수정할 수도 있습니다.

이전 로컬 커밋을 취소하는 방법

지점을 이전 위치로 재설정하면됩니다 (예 : gitk 또는 git rebase). 그런 다음 저장된 사본에서 변경 사항을 다시 적용하십시오. 로컬 리포지토리에서 가비지 수집 후 원하지 않는 커밋이 발생하지 않은 것처럼됩니다. 단일 명령으로이 모든 작업을 수행하려면 git reset HEAD~1를 사용하십시오.

경고 단어 : git reset을 (를)주의해서 사용하는 것은 작업 복사본을 혼란스러운 상태로 만드는 좋은 방법입니다. . Git 초보자는 가능하면 이것을 피하는 것이 좋습니다.

공개 커밋을 취소하는 방법

변경 사항을 취소하려면 역 체리 선택 ( git-revert )를 수행하십시오.

아직 다른 변경 사항을 지점으로 가져 오지 않은 경우 간단하게 수행 할 수 있습니다 ...

git revert --no-edit HEAD

그런 다음 업데이트 된 브랜치를 공유 저장소로 푸시하십시오.

커밋 기록은 두 커밋을 개별적으로 표시합니다 .

고급 : 공용 저장소에서 private 분기 수정

위험 할 수 있습니다. 리핑 할 지점의 로컬 사본이 있는지 확인하십시오.

또한 참고 : 다른 사람이 지점에서 작업하고있는 경우에는이 작업을 수행하지 않으려 고합니다.

git Push --delete (branch_name) ## remove public version of branch

지점을 로컬로 정리 한 다음 다시 시작하십시오 ...

git Push Origin (branch_name)

일반적인 경우, 개인 브랜치 커밋 히스토리가 원시적 인 것에 대해 걱정할 필요가 없습니다. 후속 커밋을 푸시하고 (위의 '공개 커밋을 실행 취소하는 방법'참조) 나중에 squash-merge 를 수행하여 기록을 숨기십시오.

니스 목록을 제거 할 수있는 커밋을 선택할 수있는 팝업 때문에이 작업에 git rebase -i 사용하는 것을 선호합니다. 다른 답변들과 같이 직접적이지는 않겠지 만 단지 느껴짐.

나열 할 커밋 수를 선택하고 다음과 같이 호출하십시오 (마지막 세 개를 참여 시키려면)

git rebase -i HEAD~3

샘플 목록

pick aa28ba7 Sanity check for RtmpSrv port
pick c26c541 RtmpSrv version option
pick 58d6909 Better URL decoding support

그러면 Git은 제거한 모든 행에 대한 커밋을 제거합니다.

당신이 쓰레기를 저지르고 밀었지만 푸시되지 않았다면,

git reset --soft HEAD~1

HEAD ~ 1 는 머리가되기 전 커밋의 줄임말입니다. 또는 재설정하고자하는 경우 해시의 SHA-1 을 참조 할 수 있습니다. --soft 옵션은 커밋을 지우지 만 변경된 모든 파일을 "커밋 할 변경 사항"으로 남겨 둡니다.

작업 트리에서 추적 된 파일의 변경 사항을 없애려면 머리를 사용하기 전에 커밋을 " --hard "로 사용하십시오.

OR

만약 당신이 이미 밀고 누군가가 보통 내 경우에 당겨, 당신은 자식 재설정 사용할 수 없습니다. 그러나 git revert를 할 수는 있지만,

git revert HEAD

이것은 우연한 커밋에 의해 도입 된 모든 것을 뒤집는 새로운 커밋을 생성합니다.

영구적으로 실행 취소하고 저장소를 복제 한 경우 

커밋 ID는에서 볼 수 있습니다. 

git log 

그런 다음 할 수 있습니다 -

git reset --hard <commit_id>

git Push Origin <branch_name> -f

SourceTree (GitHub 용 GUI)에서 커밋을 마우스 오른쪽 버튼으로 클릭하고 '커밋을 취소'할 수 있습니다. 변경 사항을 취소해야합니다.

터미널에서 :

또는 다음을 사용할 수 있습니다 :

git revert

또는:

git reset --soft HEAD^ # Use --soft if you want to keep your changes.
git reset --hard HEAD^ # Use --hard if you don't care about keeping your changes.

단일 명령 :

git reset --soft 'HEAD^' 

마지막 로컬 커밋을 실행 취소하는 것이 좋습니다!

git을 사용하여 아래 명령을 재설정하면됩니다.

git reset --soft HEAD~1

설명 : git reset는 기본적으로 reset로 돌아가고 싶은 커밋이면 --soft 키와 결합하면 되돌아 가고 파일에는 변경 사항을 유지합니다 ), 파일이 방금 추가 된 단계로 돌아가서 HEAD이 브랜치의 헤드이며 ~1 (이 경우 HEAD^도 사용)와 결합하면 원하는대로 하나의 커밋으로 돌아갑니다 ...

실제 상황에서 발생하고 코드를 커밋 할 수있는 모든 단계를 포함하여 아래 이미지의 단계를 자세히 설명합니다.

마지막 Git 커밋을 취소하는 방법?

모든 커밋을 마지막 커밋 이전의 상태로 복원하려면 HEAD 이전 커밋으로 다시 설정해야합니다.

1. 변경 사항을 유지하지 않으려면 다음을 수행하십시오.

   git reset --hard HEAD^
   

2. 변경 사항을 유지하려면 다음을 수행하십시오.

   git reset --soft HEAD^
   

이제 git log를 확인하십시오. 마지막 커밋이 제거되었음을 알 수 있습니다.

Reflog를 사용하여 정확한 상태 찾기

git reflog

REFLOG BEFORE RESET

올바른 reflog (나의 경우 f3cb6e2)를 선택하고 다음을 입력하십시오. 

git reset --hard f3cb6e2

그런 다음 repo HEAD가 해당 HEADid 로 재설정됩니다. LOG AFTER RESET

마지막으로 reflog는 아래 그림과 같습니다.

REFLOG FINAL

"작업 트리를 마지막 커밋으로 재설정"

git reset --hard HEAD^ 

"작업 트리에서 알 수없는 파일 정리"

git clean    

참조 - Git 빠른 참조

NOTE : 이 명령은 이전 커밋을 지우므로주의해서 사용하십시오! git reset --hard는 더 안전합니다 -

첫 번째 실행 : 

git reflog

커밋, 병합, 끌어 오기 등과 같이 저장소에서 수행 할 수있는 모든 가능한 작업을 표시합니다.

그럼 :

git reset --hard ActionIdFromRefLog

마지막 커밋 실행 취소 :

git reset --soft HEAD^ 또는 git reset --soft HEAD~

마지막 커밋을 취소합니다.

여기에서 --soft는 스테이징으로 재설정하는 것을 의미합니다.

HEAD~ 또는 HEAD^는 HEAD 이전에 커밋으로 이동하는 것을 의미합니다.

마지막 커밋을 새 커밋으로 바꾸기 :

git commit --amend -m "message"

마지막 커밋을 새로운 커밋으로 대체합니다.

또 다른 방법:

되 돌리는 지점을 체크 아웃 한 다음 로컬 작업 복사본을 원격 서버의 최신 복사본으로 다시 커밋 (모든 작업이 끝난 후 모든 작업)으로 다시 설정합니다. 이렇게하려면 SourceTree에서를 마우스 오른쪽 버튼으로 클릭하고 "BRANCHNAME을이 커밋으로 재설정"을 선택하십시오.

그런 다음 저장소의 로컬 디렉토리로 이동하여 다음 명령을 실행하십시오.

git -c diff.mnemonicprefix=false -c core.quotepath=false Push -v -f --tags REPOSITORY_NAME BRANCHNAME:BRANCHNAME

이렇게하면 로컬 저장소의 현재 커밋 이후의 모든 커밋이 지워지지만 그 하나의 분기 만 커밋됩니다.

git log를 입력하고 마지막 커밋 해시 코드를 찾은 후 다음을 입력하십시오.

git reset <the previous co>

내 경우에는 실수로 내가 원하지 않는 일부 파일을 커밋했습니다. 그래서 저는 다음과 같이했습니다.

git reset --soft HEAD^
git rm --cached [files you do not need]
git add [files you need]
git commit -c ORIG_HEAD

Gitk 또는 git log를 사용하여 결과 확인 --stat

두 가지 주요 시나리오가 있습니다

커밋을 아직 푸시하지 않았습니다

문제가 커밋 한 추가 파일 (저장소에없는 파일) 인 경우 git rm를 사용하여 제거한 다음 --amend

git rm <pathToFile>

-r를 사용하여 전체 디렉토리를 제거하거나 다른 Bash 명령과 결합 할 수도 있습니다.

git rm -r <pathToDirectory>
git rm $(find -name '*.class')

파일을 제거한 후 -amend 옵션을 사용하여 커밋 할 수 있습니다.

git commit --amend -C HEAD # the -C option is to use the same commit message

그러면 추가 파일을 제거하는 최근 로컬 커밋이 다시 작성되므로 이러한 파일은 푸시시 전송되지 않으며 GC에 의해 로컬 .git 저장소에서도 제거됩니다.

이미 커밋을 푸시했습니다

다른 시나리오와 동일한 솔루션을 적용한 다음 git Push 옵션으로 -f를 수행 할 수 있지만 권장하지는 않습니다 원격 변경 사항을 다양한 변경으로 덮어 쓰기 때문에 (저장소를 엉망으로 만들 수 있음).

대신, --amend없이 커밋을 수행해야합니다 (-amend`에 대해서는이 옵션을 기억하십시오 :이 옵션은 마지막 커밋의 기록을 다시 작성합니다).

SourceTree (Git 용 그래픽 도구)를 사용하여 커밋과 트리를 볼 수 있습니다. 마우스 오른쪽 버튼을 클릭하여 직접 수동으로 재설정 할 수 있습니다.

간단합니다. 명령 행에서 다음을 실행하십시오.

git reset --soft HEAD~ 

이전 버전으로 재설정하여 커밋되지 않은 모든 변경 사항을 영구적으로 삭제하려면 다음을 수행하십시오. 

git reset --hard HEAD~1

여러 가지 방법이 있습니다.

최종 커밋/이전 커밋을 실행 취소하려면 Git 명령을 사용하십시오.

경고 : 당신이하고있는 일을 모르는 경우 - 하드를 사용하지 마십시오 - 하드도 위험, 그리고 파일을 삭제할 수 있습니다

힘내에서 커밋을 되 돌리는 기본 명령은 :

$ git reset --hard <COMMIT -ID>

또는

$ git reset --hard HEAD~<n>

COMMIT-ID : 커밋 ID

n : 되돌리려는 마지막 커밋 수입니다.

아래와 같이 커밋 ID를 얻을 수 있습니다.

$ **git log --oneline**

d81d3f1 function to subtract two numbers

be20eb8 function to add two numbers

bedgfgg function to mulitply two numbers

d81d3f1 및 be20eb8은 커밋 ID입니다.

이제 몇 가지 사례를 보도록하겠습니다.

마지막 커밋 'd81d3f1'을 되돌리려한다고 가정하십시오. 다음은 두 가지 옵션입니다.

$ git reset --hard d81d3f1

또는

$ git reset --hard HEAD~1

커밋 'be20eb8'을 되돌리려한다고 가정하십시오.

$ git reset --hard be20eb8

더 자세한 정보를 얻으려면 헤드를 지정된 상태로 재설정하기 위해 몇 가지 다른 명령을 참조하고 사용해보십시오.

$ git reset --help

로컬 커밋의 경우

git reset --soft HEAD~1

또는 어떤 커밋인지 정확하게 기억하지 못한다면

git rm --cached <file>

푸시 된 커밋의 경우

저장소 기록에서 파일을 제거하는 올바른 방법은 git filter-branch를 사용하는 것입니다. 그건,

git filter-branch --index-filter 'git rm --cached <file>' HEAD

하지만이 명령을 신중하게 사용하는 것이 좋습니다.git-filter-branch (1) 매뉴얼 페이지에서 더 읽으십시오.

무엇을 사용합니까, reset --soft 또는 reset --hard?

나는 단지 @ Kyralessa의 대답에 대해 2 센트를 추가하고있다.

--soft (안전을 위해 - s oft를 기억하기 위해이 규칙을 사용했습니다)로 무엇을 사용해야하는지 잘 모르는 경우.

왜 ?

실수로 --hard를 선택하면 이전에 없었던대로LOSE변경됩니다. 실수로 --soft를 선택하면 추가 명령을 적용하여 --hard와 동일한 결과를 얻을 수 있습니다

git reset HEAD file.html
git checkout -- file.html

전체보기

echo "some changes..." > file.html
git add file.html
git commit -m "wrong commit"

# I need to reset
git reset --hard HEAD~1 (cancel changes)
# OR
git reset --soft HEAD~1 # Back to staging
git reset HEAD file.html # back to working directory
git checkout -- file.html # cancel changes

크레딧은 @Kyralessa로 이동합니다.

code.txt 파일이 있다고 생각하십시오. 우리는 그것에 약간의 변경을하고 커밋합니다. 이 커밋은 세 가지 방법으로 취소 할 수 있지만 먼저 준비된 파일이 무엇인지 알아야합니다 ... 준비된 파일은 커밋 할 준비가 된 파일입니다. git status을 (를) 실행하면이 파일이 녹색으로 표시되고 커밋을 위해 준비되지 않은 경우 빨간색으로 표시됩니다.

변경 사항을 커밋하면이 파일의 변경 사항이 저장되지 않습니다. git add code.txt를 사용하여이 파일을 스테이지에 추가 한 다음 변경 사항을 커밋 할 수 있습니다.

마지막 커밋 실행 취소 :

1. 이제 다른 변경없이 커밋을 취소하려면

   git reset --soft HEAD^

2. 커밋과 변경 사항을 취소하려면 ( THIS IS DANGEROUS, 변경 내용이 손실되므로 ), 우리는 사용할 수 있습니다

   git reset --hard HEAD^

3. 그리고 커밋을 취소하고 스테이지에서 변경 사항을 제거하려면

   git reset --mixed HEAD^ 또는 짧은 형식 git reset HEAD^

당신이 사용할 수있는:

git reset [email protected]{1}

이 명령은 Git 로그없이 잘못된 커밋을 삭제합니다.

대개 실수를하고 수정하기를 원하기 때문에 커밋을 실행 취소하고 싶습니다. 그래서 실제로, 커밋을 redo하고 싶습니다.

대부분의 대답은 명령 줄에 초점을 맞 춥니 다. 명령 행은 Git을 사용하는 가장 좋은 방법이지만 다른 버전 제어 시스템에서 Git을 사용하는 사람들에게는 약간 외계인이 될 수 있습니다. 

다음은 GUI를 사용하여 수행하는 방법입니다. Git을 설치했다면,이 지시 사항을 따라야 할 모든 것을 이미 확보했다.

NOTE : 나는 당신이 그것을하기 전에 커밋이 잘못되었다는 것을 깨달았다 고 가정 할 것입니다. 푸시가 무엇인지 모르는 경우 푸시하지 않았을 수 있으므로 지침을 계속 읽으십시오. 결함이있는 커밋을 푸시했다면, 가장 위험한 방법은 잘못 된 커밋을 수정하는 것입니다. 예를 들어, 사용자가 기록을 다시 쓸 수 없도록하는 버전 제어 시스템에서 수정하는 것입니다. 

즉, GUI를 사용하여 가장 최근의 결함 커밋을 수정하는 방법은 다음과 같습니다.

1. 명령 행에서 저장소로 이동하고 git gui로 GUI를 시작하십시오.
2. "최종 커밋 수정"을 선택하십시오. 마지막 커밋 메시지, 준비한 파일 및 실행하지 않은 파일이 표시됩니다.
3. 이제 항목을 원하는 모양으로 변경하고 커밋을 클릭하십시오. 

SourceTree로 작업하는 경우 도움이됩니다.

오른쪽 클릭 커밋에서 select ​​" (현재 분기)/마스터를이 커밋 으로 재설정하고 마지막 select ​​ "Soft"재설정 .

마지막 커밋을 취소하십시오. 

git reset --soft HEAD~

또는 마지막으로 커밋하기 전의 시간을 실행 취소합니다. 

git reset --soft HEAD~2

또는 이전 커밋을 실행 취소합니다. 

git reset --soft <commitID>

(git reflog를 사용하여 commitID를 얻을 수 있습니다)

이전 커밋을 실행 취소 할 때는 다음 작업으로 작업 공간을 정리하십시오.

git clean

자세한 내용은 docs : git-reset

마지막 커밋 실행 취소

코드에 마지막 커밋을 실행 취소하려는 상황이 수없이 많습니다. 예 : 당신이 그것을 광범위하게 재구성하기를 원하기 때문입니다.

이 경우 "재설정"명령은 가장 친한 친구입니다.

$ git reset --soft HEAD~1

위의 명령 (재설정)은 현재 HEAD 브랜치를 지정된 개정판으로 되감습니다. 위의 예제에서, 우리는 현재 개정 이전의 것으로 돌아가고 싶습니다. 효과적으로 커밋을 취소 할 수 있습니다.

--soft 플래그에주의하십시오. 이렇게하면 실행 취소 된 버전의 변경 사항이 보존됩니다. 명령을 실행 한 후에 변경 사항을 작업 사본에서 커밋되지 않은 로컬 수정 사항으로 확인할 수 있습니다.

이러한 변경 사항을 유지하지 않으려면 --hard 플래그를 사용하십시오. 이러한 변경 사항이 더 이상 필요하지 않을 때만이 작업을 수행하십시오.

$ git reset --hard HEAD~1

로컬 커밋을 취소하려면 git reset <commit>를 사용하십시오. 또한 튜토리얼 는 그것이 어떻게 작동하는지 보여주기 위해 매우 유용합니다.

또는 git revert <commit> : reverting 를 사용하여 변경 내용을 롤백하는 다른 커밋을 추가하려는 경우 (그러나 프로젝트 기록에 그대로 유지) 사용해야합니다.

일반적인 Git 사이클

이전 답변에서 힘내 관련 명령에 관해서는 도움이 될만한 모든 독자와 함께 일반적인 힘내기주기를 공유하고 싶습니다. 여기 힘내와 함께 일하는 방법,

1. 원격 서버에서 처음 복제

   git clone $project

2. 원격에서 당기기 (푸시하기 위해 대기중인 로컬 커밋이없는 경우)

   git pull

3. $ to_be_committed_list에 새 로컬 file1 추가 ($ to_be_committed_list는 staged 영역을 의미 함)

   git add $file1

4. $ to_be_committed_list에서 실수로 file2를 제거했습니다. (필자가 원하지 않는 file2가 3 단계처럼 추가되었다고 가정하십시오.)

   git reset $file2

5. $ to_be_committed_list에있는 file1 커밋

   git commit -m "commit message description"

6. 푸시하기 전에 로컬 저장소와 원격 커밋 동기화

   git pull --rebase

7. 충돌이 발생할 때 해결 전제 조건 mergetool 구성

   git mergetool #resolve merging here, also can manually merge

8. 충돌 해결 된 파일을 추가하는 경우 file1를 가정 해 봅시다.

   git add $file1

9. 이전 rebase 명령 계속하기

   git rebase --continue

10. 푸시 준비 및 이미 마지막 로컬 커밋 동기화

    git Push Origin head:refs/for/$branch # branch = master, dev, etc.

제 경우에는 저의 잘못을 저 지르려고했습니다. 그래서 제가 원했던 것은 제 모든 변화를 다시 되돌려 놓고 새로운 올바른 지점에 맡길 수있게하기 위해서였습니다.

커밋하고 푸시 한 동일한 브랜치에서 "git status"를 입력하면 커밋하고 푸시했기 때문에 새로운 것이 표시되지 않습니다. 이제 다음을 입력하십시오.

git reset --soft HEAD~1

이것은 무대 영역에서 모든 변경 (파일)을 되찾아서 입력 한 작업 디렉토리 (무단)에서 다시 가져옵니다 :

git reset FILE

여기서 "파일"은 다시 커밋 할 파일입니다. 이제이 FILE은 당신이했던 모든 변화와 함께 작업 디렉토리 (unstaged)에 있어야합니다. 이제 원하는 지점으로 변경하고 해당 지점에서 변경 사항을 커밋 할 수 있습니다. 이것이 내가했던 동일한 실수를 저지른 다른 사람들을 도울 수 있기를 바랍니다. 물론 커밋 한 초기 브랜치는 여전히 모든 변경 사항과 함께 있지만, 제 경우에는 괜찮습니다. 그렇지 않은 경우 해당 브랜치에서 커밋을 되돌릴 수있는 방법을 찾을 수 있습니다.

비주얼 스튜디오 사용자 (2015 등)

Visual Studio에서 "개발"과 같은 지점으로 푸시 할 수 없기 때문에 Visual Studio에서 동기화 할 수 없다면 Visual Studio에서되돌리기NOR재설정(하드 또는 소프트)가 작동합니다.

TONS OF VOTES의 답변에 따르면

프로젝트의 루트 프롬프트 (Prompt of project)를 사용하여 푸시하려고 시도 할 모든 것을 누락시킵니다.

git reset --hard HEAD~1

파일을 백업하거나 우편으로 보내기 만하면 작업을 잃지 않으려 고합니다.

bitbucket에서 커밋 ID를받은 다음 수행했습니다.

git checkout commitID .

예:

git checkout 7991072 .

그리고 그것은 그 커밋의 작업 복사본으로 되돌려 놓았습니다.

로컬로 잘못 커밋하여 원격 저장소에 밀어 넣었다 고 가정합니다. 다음 두 명령으로 엉망진창을 취소 할 수 있습니다.

먼저 우리가 원하는 커밋으로 돌아가서 로컬 저장소를 수정해야합니다.

git reset --hard <previous good commit id where you want the local repository  to go>

이제 우리는 강제로이 명령을 사용하여 원격 저장소에서이 좋은 커밋을 푸시합니다.

git Push --force-with-lease

강제 옵션의 '리스료'버전을 사용하면 알지 못하는 새로운 커밋을 우발적으로 삭제하는 것을 방지 할 수 있습니다 (예 : 마지막 풀 이후 다른 소스에서 오는 것).

마지막 커밋을 취소합니다 :

git reset --soft HEAD^ or git reset --soft HEAD~

마지막 커밋을 취소합니다.

여기에서 --soft는 스테이징으로 재설정하는 것을 의미합니다.

HEAD~ or HEAD^는 HEAD 이전에 커밋으로 이동하는 것을 의미합니다.

마지막 커밋을 새 커밋으로 바꾸기 :

git commit --amend -m "message"

마지막 커밋을 새로운 커밋으로 대체합니다.

쉽고 빠르게해야합니다.

    git commit --amend

사설 지사 또는

    git commit -m 'Replace .class files with .Java files'

공유 또는 공용 지점 인 경우.

마지막 커밋을 실행 취소 할 수있는 몇 가지 옵션이 있습니다. 다음은 몇 가지 옵션을 코드 스 니펫으로 단일 답변으로 요약 한 것입니다

우선 무엇을 버려야 할 "잘못된"커밋인지 알아야합니다. 우리는 그것을 찾기 위해 git reflog를 사용할 것입니다.

git reflog

reflog도 항상 사용할 수 있습니다.
git reflog는 HEAD을 업데이트 한 모든 변경 사항을 표시하고 원하는 reflog 항목을 체크하면 HEAD이 다시이 커밋으로 설정됩니다. 

HEAD가 수정 될 때마다 reflog에 새 항목이 생깁니다.
reflog은 unix history 명령과 유사하며 시스템에 로컬로 보관됩니다.

git reflog
git checkout [email protected]{...}
# or
git checkout <sha-1>

체크 아웃을 사용하면 원하는 커밋으로 되돌아 갈 수 있고 git checkout이 할 수있는 지점이나 다른 옵션을 만들 수 있습니다.

git reset HEAD --hard <commit_id>

"Move" 머리를 원하는 커밋으로 되돌립니다.
힘내 재설정은 당신이 선택하는 --hard/--soft/--mixed 값에 따라 작업 공간 및/또는 작업 디렉토리에 대해 원하는 커밋 내용을 체크 아웃합니다. --hard는 지정된 내용으로 스테이지 영역과 작업 디렉토리를 모두 업데이트하고 로컬 브랜치에서이 지점을 넘어서 다른 모든 커밋을 "분리"합니다. 

이러한 커밋이 다른 지사의 일부가 아닌 경우 "커밋"됩니다.
"dangle"컨텐츠 란 로컬 저장소에 도달 할 수없는 컨텐츠를 의미합니다.이 컨텐츠는 다른 브랜치의 일부가 아니며 gc에 의해 제거되거나 제거 될 수 있습니다.

# This will destroy any local modifications.
# Don't do it if you have uncommitted work you want to keep.
git reset --hard 0d1d7fc32

# Alternatively, if there's work to keep:
git stash
git reset --hard 0d1d7fc32
git stash pop
# This saves the modifications, then reapplies that patch after resetting.
# You could get merge conflicts, if you've modified things which were
# changed since the commit you reset to.

이 스키마는 어떤 명령이 무엇을하는지 설명합니다.
거기에서 볼 수 있듯이 reset && checkout는 HEAD을 수정합니다.

이 명령을 사용하십시오.

git checkout -b old-state number_commit

이 명령 사용

git checkout -b old-state 0d1d7fc32

이미 Github에 푸시 된 커밋을 제거하십시오.

git Push Origin +(previous good commit id):(branch name)

Github에서 다시 원래대로 설정하려는 마지막 커밋 ID를 지정하십시오.

예를 들어. 최신 커밋 ID가 잘못 되었다면 위의 git 명령에서 분기 이름과 함께 이전 커밋 ID를 지정하십시오. 

git log를 사용하여 이전 커밋 ID를 얻을 수 있습니다.

마지막 커밋, 마지막 2 커밋 및 마지막 n 커밋의 모든 변경 사항을 제거하려면 다음을 수행하십시오.

git reset --hard HEAD~1
git reset --hard HEAD~2
...
git reset --hard HEAD~n

그리고 특정 커밋 후에 아무 것도 없애기 위해서 :

git reset --hard <commit sha>

예를 들어, 

git reset --hard 0d12345

추신:
1- "하드"옵션 때문에 조심하십시오. 당신의 repo에서도 로컬 변경 사항을 삭제하고 이전에 언급 한 커밋으로 되돌립니다. 당신이 마지막 커밋 ()을 엉망으로 만들고 시간 안에 다시 가고 싶다면 당신 은 이것을 실행해야합니다. 

2- 보통 7 자의 "commit sha"로 충분하지만 더 큰 프로젝트에서는 고유 한 것을 보장하기 위해 최대 12 자의 글자가 필요할 수 있습니다. 당신 또한 전체 40 글자를 말할 수 있습니다.

3 위의 명령은 Windows 용 Github에서도 작동합니다.

항상 이전 버전의 git checkout <SHA code>를 수행 한 다음 새 코드로 다시 커밋 할 수 있습니다.

Git 커밋은 두 가지 방법으로 실행 취소 할 수 있습니다. 먼저 커밋 내역을 유지하려면 git revert를 사용할 수 있습니다.

git revert HEAD~3
git revert <hashcode of commit>
를 사용할 수 있습니다. git reset는 모든 커밋 내역을 삭제하고 원하는 위치로 커밋하도록 이끌 것입니다.
git reset <hashcode of commit>
git reset HEAD~3
 키워드 중 하나라도 동작하는 경우 --hard 키워드를 사용할 수 있습니다. 그러나, 극도로 필요하기 전까지 만 권장합니다.

Git reset --mixed, --soft 및 --hard의 차이점

전제 조건 : 저장소의 기존 파일을 수정하면이 변경 사항은 초기에 스테이지되지 않은 것으로 간주됩니다. 변경 사항을 커밋하려면 준비해야합니다. 즉, git add를 사용하여 인덱스에 변경 사항을 추가해야합니다. 커밋 작업 중에 준비된 파일이 인덱스에 추가됩니다.

예를 들어 보자.

- A - B - C (master)

HEAD은 C을 가리키고 인덱스는 C과 일치합니다.

--부드러운

• 커밋 C 및 마스터/HEAD를 B로 설정하여 git reset --soft B을 실행할 때.
• 마스터/HEAD는 이제 B를 가리 키지 만 색인은 여전히 ​​C에서 변경되었습니다.
• git status을 실행하면 commit C에서 staged로 색인이 생성 된 파일을 볼 수 있습니다.
• 이 시점에서 git commit를 실행하면 C와 동일한 변경 사항

-혼합

• git reset --mixed B를 실행하십시오.
• 실행시 master/HEAD는 B를 가리키고 혼합 플래그로 인해 색인도 B와 일치하도록 수정됩니다.
• 이 시점에서 git commit을 실행하면 index matches HEAD 이후 아무 일도 일어나지 않습니다.
• 작업 디렉토리에는 여전히 변경 사항이 있지만, 색인에 없기 때문에 git status는 unstaged로 표시됩니다.
• 커밋하려면 git add하고 평소처럼 커밋하십시오.

--단단한

• git reset --hard B 실행
• 실행시 master/HEAD는 B 및 작업 디렉토리 수정을 가리 킵니다.
• C에 추가 된 변경 사항 및 커밋되지 않은 모든 변경 사항은 제거됨입니다.
• 작업 사본의 파일은 커밋 B와 일치하므로 커밋 C에서 작성된 모든 변경 사항과 커밋되지 않은 변경 사항이 영구적으로 손실됩니다.

git reset 명령과 함께 사용할 수있는 플래그를 비교하면 누군가가 현명하게 사용할 수 있기를 바랍니다. 자세한 내용은 다음을 참조하십시오 link1 & link2

참조 : 힘내에서 마지막 커밋을 취소하는 방법?

Git Extensions가 설치되어 있으면 커밋을 쉽게 실행 취소/되돌릴 수 있습니다 (git 확장은 here 에서 다운로드 할 수 있습니다).

Git Extensions를 열고, 되돌릴 커밋을 마우스 오른쪽 단추로 클릭 한 다음 "되돌리기 커밋"을 선택하십시오. 

팝업이 열립니다 (아래 스크린 샷 참조).

되돌릴 변경 사항을 직접 커밋하려면 "자동 커밋 만들기"를 선택하거나 되돌릴 변경 사항을 수동으로 커밋하려면 상자를 선택하지 않은 상태로 유지하고 "커밋 되돌리기"버튼을 클릭하십시오.

git reset --hard <last good SHA>를 사용하여 변경 사항을 재설정하고 새로운 커밋을 제공하십시오. git checkout -- <bad filename>를 사용할 수도 있습니다.

나는 당신이 저장소에 투입 한 것을 취소하는 방법을 설명하는 this site를 발견했다.

일부 명령 :

git commit --amend        # Change last commit
git reset HEAD~1 --soft   # Undo last commit

다음은 site : Oh shit, git! 입니다.

다음은 Git에서 작업을 실행 취소하는 많은 방법입니다. 그들 중 일부 :

젠장, 마지막 커밋에서 메시지를 바꿔야 해!

git commit --amend
# follow prompts to change the commit message

오, 젠장, 나는 우연히 새로운 지사에 있어야했던 것을 마스터하기 위해 무언가를 저질렀다!

# Create a new branch from the current state of master
git branch some-new-branch-name
# Remove the commit from the master branch
git reset HEAD~ --hard
git checkout some-new-branch-name
# Your commit lives in this branch now :)

로컬 저장소에서 커밋을 실행 취소 할 수 있습니다. 아래 시나리오를 따르십시오.

아래 그림에서 로컬 인 'test'브랜치 (Git 명령 git checkout -b test 사용)와 로컬 브랜치 (Git 명령 git status 사용)를 점검하여 커밋 할 것이 없다는 것을 확인합니다.

다음 이미지 이미지에서 나는 Filter1.txt 에서 몇 가지 변경을하고 그 파일을 준비 영역에 추가 한 다음 내 변경 사항을 일부 메시지 (Git 명령 git commit -m "Doing commit to test revert back" 사용)로 커밋했습니다.

"-m은 커밋 메시지"

다음 이미지에서 커밋 한 내용을 볼 수 있습니다 (Git 명령 git log 사용).

위의 이미지에서 각 커밋과 함께 커밋 ID를 볼 수 있습니다. 이제 커밋 메시지를 통해 커밋 ID를 볼 수 있습니다. 커밋 ID를 복사하고 실행을 취소하고 아래의 Git 명령 git revert {"paste your commit id"}을 누르면됩니다. 예:

git revert 9ca304ed12b991f8251496b4ea452857b34353e7

나는 나의 마지막 커밋을 되 돌렸다. 이제 Git 상태를 확인하면 Filter1.txt 와 아직 커밋되지 않은 수정 된 파일을 볼 수 있습니다.

마지막 커밋을 취소하는 가장 간단한 방법은 다음과 같습니다.

git reset HEAD^

커밋을하기 전에 프로젝트 상태가 나타납니다.

IntelliJ IDEA에서 Git 저장소 로그를 열려면 Alt+9, 커밋 목록의 일부 태그를 마우스 오른쪽 버튼으로 클릭하고 "여기에 현재 분기 재설정 ...".

HEAD :

Reset 커밋 전에 HEAD에 대해 알아야합니다 ... HEAD는 작업 디렉토리의 현재 상태뿐입니다. 확약 번호로 표시됩니다.

힘내 자 :

고유 한 태그로 표시되는 커밋 아래에 할당 된 각 변경 사항입니다. 커밋은 삭제할 수 없습니다. 마지막 커밋을 원할 경우 git reset를 사용하여 간단히 살펴볼 수 있습니다.

두 가지 방법을 사용하여 마지막 커밋을 할 수 있습니다.

방법 1 : (커밋 번호를 모르지만 맨 처음으로 이동하려는 경우)

git reset HEAD~1  # It will move your head to last commit

방법 2 : (커밋을 알고 있다면 간단히 알려진 커밋으로 리셋)

git reset 0xab3 # 커밋 번호

참고 : 최근 커밋을 알고 싶다면 시도하십시오 git log -p -1

다음은 그래픽 표현입니다.

베이스 분기에 패치를 제안 할 때 히스토리를 깨끗하게 유지하고 싶을 때 커밋 재배치 및 삭제가 가장 좋습니다.

최상위 커밋을 삭제해야하는 경우 다음 한 줄자가 도움이됩니다.

git rebase --onto HEAD~1 HEAD

하지만 당신이 한 많은 커밋 중에서 1 개를 떨어 뜨리고 싶다면

a -> b -> c -> d -> 마스터

당신은 커밋 'c'를 드롭하고 싶습니다.

git rebase --onto b c

이것은 'b'를 'd'의 새로운 기초로 삼아 'c'를 제거합니다.

다음과 같이 로그를보고 마지막 커밋 해시 코드를 찾습니다.

git log

그때

git reset <the previous co>

완전을 기하기 위해 이전 답변에서 간과 한 분명한 방법을 알려 드리겠습니다.

커밋이 푸시되지 않았으므로 리모컨은 변경되지 않았으므로 다음을 수행합니다.

1. 로컬 저장소를 삭제하십시오.
2. 원격 저장소를 복제하십시오.

멋진 Git 클라이언트가 작별 인사를하는 경우 가끔 필요합니다. (예 : non-fast-forward 오류)

마지막 Push 이후에 saved changes를 다시 커밋하는 것을 잊지 마십시오.

Visual Studio에서 작업하고 있다고 가정하면 분기 기록을보고 모든 커밋을 살펴보고 실행 취소 할 커밋 이전에 이벤트를 선택하고 마우스 오른쪽 단추로 클릭 한 다음 Revert을 선택하기 만하면됩니다. 그만해.

잘못된 파일을 제거하고 싶다면 반드시해야합니다. 

git reset --soft <your_last_good_commit_hash_here> 여기서 git status를 수행하면 준비 영역에 파일이 표시됩니다. 잘못된 파일을 선택하여 준비 영역에서 가져올 수 있습니다.

다음과 같이.

git reset wrongFile1 wrongFile2 wrongFile3

이제 필요한 파일을 밀어 넣기 만하면됩니다.

git add goodFile1 goodFile2

그들을 저주하다 

git commit -v 또는 git commit -am "Message"

푸시 및 푸시

git Push Origin master

그러나 변경된 파일에 대해 신경 쓰지 않으면 이전의 올바른 커밋으로 하드 재설정하고 모든 것을 서버에 푸시 할 수 있습니다.

으로 

git reset --hard <your_last_good_commit_hash_here>

git Push Origin master

서버에 잘못된 파일을 이미 게시 한 경우 --force 플래그를 사용하여 서버에 푸시하고 기록을 편집 할 수 있습니다.

git Push --force Origin master

이 파일을 추가하지 않은 이전 커밋을 하드 리셋 한 다음 시도해보십시오.

git reset --hard <commit_hash>

경우에 따라 변경 사항을 백업했는지 확인하십시오. 하드 리셋이므로 손실 될 수 있습니다 (이전에 숨겨 놓지 않은 경우).

git reset --soft HEAD~1

재설정은 현재 HEAD 브랜치를 지정된 개정으로 되감습니다. 주 thesoft 플래그 : 이것은 실행 취소 된 개정의 변경 사항이 보존되도록합니다. 명령을 실행 한 후에 변경 사항을 작업 사본에서 커밋되지 않은 로컬 수정 사항으로 확인할 수 있습니다.

이러한 변경 사항을 유지하지 않으려면 --hard 플래그를 사용하십시오. 이러한 변경 사항이 더 이상 필요하지 않을 때만이 작업을 수행하십시오.

 git reset --hard HEAD~1

다중 커밋 실행 취소

git reset --hard 0ad5a7a6

그러나 reset 명령을 사용하면 리턴 한 명령 다음에 오는 모든 커밋이 취소됩니다.  

내가 커밋을 취소해야 할 때마다/커밋은 :

1. git reset HEAD~<n> // 취소 할 필요가있는 마지막 커밋 수

2. git status // 선택적. 모든 파일은 이제 빨간색으로 나타납니다 (unstaged).

3. 자, 내가 할 수있는 추가 및 커밋 그냥 파일 :

   • git add <file names> & git commit -m "message" -m "details"
4. 선택 사항 : 필요한 경우 나머지 파일의 변경 사항을 체크 아웃과 함께 이전 상태로 롤백 할 수 있습니다.
   • git checkout <filename>
5. 만약 내가 이미 원거리 원점 (Origin)으로 밀고 있었다면, 이전에 :
   • git Push Origin <branch name> -f // 밀어 넣기를 강제하려면 -f를 사용하십시오.

Repo에서 첫 번째 커밋을 실행 취소하려는 경우

이 문제가 발생합니다.

$ git reset HEAD~
fatal: ambiguous argument 'HEAD~': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions, like this:
'git <command> [<revision>...] -- [<file>...]'

마지막 커밋이 리포지토리의 초기 커밋 (또는 부모 없음) 인 경우 HEAD ~가 없기 때문에 오류가 발생합니다.

해결책

"master"브랜치에서만 유일한 커밋을 재설정하고자하는 경우

$ git update-ref -d HEAD
$ git rm --cached -r .

다음 단계를 수행하십시오. 도움이 될 수 있습니다.

단계 : 1

git log 조회

로그 목록에서 마지막 커밋 해시 코드를 찾은 후 다음을 입력하십시오.

단계 : 2

git reset <hash code>

이 커맨드를 사용하여 마지막 커밋 ID를 얻으십시오 (맨 위의 로그 하나가 최신 커밋입니다).

git log

커밋 ID (GUID)를 가져 와서 다음 명령을 실행합니다.

git revert <commit_id>

방법 편집 이전 커밋

일반적으로 나는 많은 커밋을 취소하고 싶지 않지만, 오히려 내가 먼저 커밋했으면하는 바램에 대한 커밋을 편집한다.

과거 커밋을 자주 수정하여 스크립트를 작성했습니다.

워크 플로우는 다음과 같습니다.

1. git commit-edit <commit-hash>
   

   이렇게하면 편집하려는 커밋에서 삭제됩니다.

   커밋의 변경 사항은 un 단계가되어 처음으로 원할 때 준비가됩니다.

2. 처음부터 그랬 으면 좋겠어.

   (git stash save --keep-index를 사용하여 커밋하지 않는 파일을 다람쥐로 처리 할 수 ​​있습니다)

3. --amend로 커밋을 다시 실행하십시오. 예 :

   git commit --amend
   

4. Rebase 완료 :

   git rebase --continue
   

다음과 같이 git-commit-edit를 호출하고 $PATH에 넣습니다.

#!/bin/bash

# Do an automatic git rebase --interactive, editing the specified commit
# Revert the index and working tree to the point before the commit was staged
# https://stackoverflow.com/a/52324605/5353461

set -euo pipefail

script_name=${0##*/}

warn () { printf '%s: %s\n' "$script_name" "$*" >&2; }
die () { warn "[email protected]"; exit 1; }

[[ $# -ge 2 ]] && die "Expected single commit to edit. Defaults to HEAD~"

# Default to editing the parent of the most recent commit
# The most recent commit can be edited with `git commit --amend`
commit=$(git rev-parse --short "${1:-HEAD~}")

# Be able to show what commit we're editing to the user
if git config --get alias.print-commit-1 &>/dev/null; then
  message=$(git print-commit-1 "$commit")
else
  message=$(git log -1 --format='%h %s' "$commit")
fi

if [[ $OSTYPE =~ ^darwin ]]; then
  sed_inplace=(sed -Ei "")
else
  sed_inplace=(sed -Ei)
fi

export GIT_SEQUENCE_EDITOR="${sed_inplace[*]} "' "s/^pick ('"$commit"' .*)/edit \\1/"'
git rebase --quiet --interactive --autostash --autosquash "$commit"~
git reset --quiet @~ "$(git rev-parse --show-toplevel)"  # Reset the cache of the toplevel directory to the previous commit
git commit --quiet --amend --no-edit --allow-empty  #  Commit an empty commit so that that cache diffs are un-reversed

echo
echo "Editing commit: $message" >&2
echo

모든 로컬 변경/커밋을 휴지통에서 제거하고 로컬 브랜치를 시작한 Origin 브랜치처럼 보이게하려면 ...

git reset --hard Origin/branch-name

나는이 같은 문제를 직접 겪은 후이 시대에 대해 썼습니다.

https://ao.gl/how-to-delete-revert-a-git-commit/

기본적으로 다음을 수행하면됩니다.

git log, SHA의 처음 7자를 가져온 다음 git revert <sha> 다음에 git Push --force을 수행하십시오.

git revert <sha> -m -1와 git Push와 같이 Git revert 명령을 사용하여이를 되돌릴 수도 있습니다.

git revert commit

이렇게하면 되돌리려는 커밋과 반대의 변경 사항을 생성 한 다음 변경 사항을 커밋합니다. 나는 이것이 가장 간단한 방법이라고 생각한다.

https://git-scm.com/docs/git-revert

git revert <commit-id>를 사용할 수 있습니다.

커밋 ID를 얻으려면 git log을 사용하십시오.

변경 사항을 포함한 로컬 버전을 서버 버전으로 바꾸면이 두 줄의 코드는 git이 로컬로 가져오고 덮어 쓰게합니다. 명령 프롬프트를 열고 자식 프로젝트 루트로 이동합니다. VS를 사용하는 경우 팀, 동기화를 클릭하고 아래의 "명령 프롬프트 열기"(이미지 참조)를 클릭하십시오. 

Cmd 프롬프트에서 다음 두 가지 지침을 따르십시오. 

git fetch --all

그럼 너는

git reset --hard Origin/master

기존 로컬 버전을 git 서버의 버전으로 덮어 씁니다.

git Push --delete (branch_name) //this will be removing the public version of your branch

git Push Origin (branch_name) //This will add the previous version back