You are to play the role of a software programming tutorial writer. You will be presented with a PRIMARY QUESTION and one or more reasonable ANSWERS TO THE PRIMARY QUESTION. You are tasked to write an original tutorial based on these provided materials. You must follow the following rules:
The tutorial should be geared towards intermediate software engineers. It should be presented in an informative, friendly, and professional tone.
You must use each of the provided KEYWORDS AND PHRASES at least 10 times in the tutorial.
You must cover all of the material presented in the question and answers, rephrasing to synthesize related points and match the desired tone.
You may add additional context if it helps to further explain the points made in the original question and answer. Any such sections not immediately derived from the provided materials should be marked explicitly (ex. “Added Context: …”).
The question may contain failed attempts at solving the underlying problem or performing the desired task. Do not use these attempts in your tutorial.
You must demonstrate the tutorial content with at least one code example. The code example must be fully executable and only use common packages, but not anything such as data files that do not exist. This example should not be verbatim from the provided question and answers.
The code example must be used consistently throughout the article. This may involve building up the example from parts, showing different ways to do the task using the same core example, dissecting what the example does, etc.
Write the tutorial in compilable Markdown.

The material for you to write about follows below:
KEYWORDS AND PHRASES: git, version-control, git-commit, undo
PRIMARY QUESTION: I accidentally committed the wrong files to Git, but didn't push the commit to the server yet.

How do I undo those commits from the local repository?

ANSWERS TO THE PRIMARY QUESTION:
Answer 1:
Undo a commit & redo
$ git commit -m "Something terribly misguided" # (0: Your Accident)
$ git reset HEAD~ # (1)
[ edit files as necessary ] # (2)
$ git add . # (3)
$ git commit -c ORIG\_HEAD # (4)
git reset is the command responsible for the undo. It will undo your last commit while leaving your working tree (the state of your files on disk) untouched. You'll need to add them again before you can commit them again).
Make corrections to working tree files.
git add anything that you want to include in your new commit.
Commit the changes, reusing the old commit message. reset copied the old head to .git/ORIG\_HEAD; commit with -c ORIG\_HEAD will open an editor, which initially contains the log message from the old commit and allows you to edit it. If you do not need to edit the message, you could use the -C option.
Alternatively, to edit the previous commit (or just its commit message), commit --amend will add changes within the current index to the previous commit.

To remove (not revert) a commit that has been pushed to the server, rewriting history with git push origin main --force[-with-lease] is necessary. It's almost always a bad idea to use --force; prefer --force-with-lease instead, and as noted in the git manual:

You should understand the implications of rewriting history if you [rewrite history] has already been published.

Answer 2:
Undoing a commit is a little scary if you don't know how it works. But it's actually amazingly easy if you do understand. I'll show you the 4 different ways you can undo a commit.

Say you have this, where C is your HEAD and (F) is the state of your files.

 (F)
A-B-C
 ↑
 master
Option 1: git reset --hard
You want to destroy commit C and also throw away any uncommitted changes. You do this:

git reset --hard HEAD~1
The result is:

 (F)
A-B
 ↑
master
Now B is the HEAD. Because you used --hard, your files are reset to their state at commit B.

Option 2: git reset
Maybe commit C wasn't a disaster, but just a bit off. You want to undo the commit but keep your changes for a bit of editing before you do a better commit. Starting again from here, with C as your HEAD:

 (F)
A-B-C
 ↑
 master
Do this, leaving off the --hard:

git reset HEAD~1
In this case, the result is:

 (F)
A-B-C
 ↑
master
In both cases, HEAD is just a pointer to the latest commit. When you do a git reset HEAD~1, you tell Git to move the HEAD pointer back one commit. But (unless you use --hard) you leave your files as they were. So now git status shows the changes you had checked into C. You haven't lost a thing!

Option 3: git reset --soft
For the lightest touch, you can even undo your commit but leave your files and your index:

git reset --soft HEAD~1
This not only leaves your files alone, it even leaves your index alone. When you do git status, you'll see that the same files are in the index as before. In fact, right after this command, you could do git commit and you'd be redoing the same commit you just had.

Option 4: you did git reset --hard and need to get that code back
One more thing: Suppose you destroy a commit as in the first example, but then discover you needed it after all? Tough luck, right?

Nope, there's still a way to get it back. Type this

git reflog
and you'll see a list of (partial) commit shas (that is, hashes) that you've moved around in. Find the commit you destroyed, and do this:

git checkout -b someNewBranchName shaYouDestroyed
You've now resurrected that commit. Commits don't actually get destroyed in Git for some 90 days, so you can usually go back and rescue one you didn't mean to get rid of.
소프트웨어 프로그래밍 튜토리얼 작성자의 역할을 수행해야 합니다. 기본 질문과 기본 질문에 대한 하나 이상의 합리적인 답변이 제시됩니다. 이 제공된 자료를 바탕으로 독창적인 튜토리얼을 작성해야 합니다. 다음 규칙을 따라야 합니다:
튜토리얼은 중급 소프트웨어 엔지니어를 대상으로 작성해야 합니다. 유익하고 친근하며 전문적인 어조로 작성해야 합니다.
튜토리얼에서 제공된 각 키워드와 문구를 최소 10회 이상 사용해야 합니다.
질문과 답변에 제시된 모든 자료를 다루어야 하며, 관련 요점을 종합하고 원하는 어조와 일치하도록 문구를 바꿔야 합니다.
원래 질문과 답변의 요점을 추가로 설명하는 데 도움이 되는 경우 추가 문맥을 추가할 수 있습니다. 제공된 자료에서 바로 도출되지 않은 부분은 명시적으로 표시해야 합니다(예: "추가 문맥: ...").
문제에는 근본적인 문제를 해결하거나 원하는 작업을 수행하기 위한 실패한 시도가 포함될 수 있습니다. 이러한 시도는 자습서에서 사용하지 마십시오.
하나 이상의 코드 예제를 사용하여 자습서 콘텐츠를 시연해야 합니다. 코드 예제는 완전히 실행 가능해야 하며 일반적인 패키지만 사용해야 하며 존재하지 않는 데이터 파일과 같은 것은 사용하지 않아야 합니다. 이 예제는 제공된 질문과 답변의 내용을 그대로 옮겨서는 안 됩니다.
코드 예제는 문서 전체에서 일관되게 사용해야 합니다. 여기에는 예제를 부분적으로 구성하거나, 동일한 핵심 예제를 사용하여 작업을 수행하는 다양한 방법을 보여주거나, 예제가 수행하는 작업을 분석하는 등의 방법이 포함될 수 있습니다.
컴파일 가능한 마크다운으로 튜토리얼을 작성하세요.

작성할 자료는 다음과 같습니다:
키워드 및 구문: git, 버전 제어, git-commit, 실행 취소
주요 질문: 실수로 잘못된 파일을 Git에 커밋했지만 아직 서버에 커밋을 푸시하지 않았습니다.

로컬 리포지토리에서 해당 커밋을 실행 취소하려면 어떻게 해야 하나요?

주요 질문에 대한 답변:
답변 1:
커밋을 실행 취소하고 다시 실행
$ git commit -m "뭔가 끔찍하게 잘못된 것" # (0: 당신의 사고)
git reset HEAD~ # (1)
[필요에 따라 파일 편집 ] # (2)
$ git add . # (3)
$ git commit -c ORIG\_HEAD # (4)
git reset은 실행 취소를 담당하는 명령이다. 이 명령은 작업 트리(디스크에 있는 파일 상태)는 그대로 유지하면서 마지막 커밋을 실행 취소한다. 다시 커밋하려면 다시 추가해야 한다).
작업 트리 파일을 수정한다.
새 커밋에 포함할 내용을 git에 추가한다.
이전 커밋 메시지를 재사용하면서 변경 사항을 커밋한다. 재설정 이전 헤드를 .git/ORIG\_HEAD에 복사하고 -c ORIG\_HEAD로 커밋하면 이전 커밋의 로그 메시지가 포함된 편집기가 열리고 이를 편집할 수 있다. 메시지를 편집할 필요가 없다면 -C 옵션을 사용할 수 있다.
또는 이전 커밋(또는 해당 커밋 메시지만)을 편집하려면 커밋 --amend를 사용하면 현재 인덱스 내의 변경 내용을 이전 커밋에 추가합니다.

서버에 푸시된 커밋을 제거하려면(되돌리지 않으려면) git push origin main --force[-with-lease]로 히스토리를 다시 작성해야 한다. 거의 항상 --force를 사용하는 것은 좋지 않은 생각이며, 대신 --force-with-lease를 사용하는 것이 좋으며, git 매뉴얼에 명시된 대로 사용한다:

이미 [히스토리 다시 쓰기]가 게시된 경우 히스토리 다시 쓰기의 의미를 이해해야 한다.

답변 2:
커밋을 실행 취소하는 것은 어떻게 작동하는지 모른다면 조금 무섭다. 하지만 이해한다면 실제로는 놀라울 정도로 쉽습니다. 커밋을 실행 취소하는 4가지 방법을 보여드리겠습니다.

C는 HEAD이고 (F)는 파일 상태라고 가정해 보겠습니다.

 (F)
A-B-C
 ↑
 마스터
옵션 1: git reset --hard
커밋 C를 삭제하고 커밋되지 않은 변경 사항도 모두 버리려고 한다. 이렇게 한다:

git reset --hard HEAD~1
결과는 다음과 같다:

 (F)
A-B
 ↑
master
이제 B가 HEAD가 되었다. hard를 사용했기 때문에 파일은 커밋 B의 상태로 초기화된다.

옵션 2: git 리셋
커밋 C가 재앙은 아니었지만 약간 잘못되었을 수도 있습니다. 커밋을 되돌리고 싶지만 더 나은 커밋을 하기 전에 약간의 편집을 위해 변경 내용을 유지하려고 한다. 여기서부터 다시 시작하여 C를 HEAD로 사용한다:

 (F)
A-B-C
 ↑
 마스터
하드에서 --hard를 빼고 이렇게 한다:

git reset HEAD~1
이 경우 결과는 다음과 같다:

 (F)
A-B-C
 ↑
마스터
두 경우 모두 HEAD는 최신 커밋에 대한 포인터일 뿐이다. git 리셋 HEAD~1을 수행하면 Git에게 HEAD 포인터를 한 커밋 뒤로 이동하라고 지시한다. 하지만 (--hard를 사용하지 않는 한) 파일은 그대로 유지된다. 이제 git 상태에 C에 체크 아웃한 변경 사항이 표시됩니다. 아무것도 잃지 않았어요!

옵션 3: git 리셋 --soft
커밋을 실행 취소하되 파일과 인덱스는 그대로 둘 수도 있다:

git reset --soft HEAD~1
이렇게 하면 파일뿐만 아니라 인덱스도 그대로 유지된다. git status를 실행하면 이전과 동일한 파일이 인덱스에 있는 것을 볼 수 있습니다. 실제로 이 명령을 실행한 직후에 git 커밋을 실행하면 방금 실행한 것과 동일한 커밋을 다시 실행하게 됩니다.

옵션 4: git 리셋 --hard를 수행했는데 해당 코드를 다시 가져와야 하는 경우
한 가지 더: 만약 