Git Commands Flashcards: Everyday Workflow, Branching & Recovery
Practice essential Git commands with safe, current examples for staging, commits, branches, remotes, history, undoing changes, and recovery.
Tietoja tästä pakasta
Git commands are easier to remember when the prompt starts with a real situation: inspect a change, stage part of a file, move work onto a branch, update from a remote, or recover a commit that seemed lost.
What this deck practices
- Situation → command: choose a practical Git command or safe command sequence for the state in front of you.
- Command → effect: explain what a command reads or changes, including the working tree, index, branch, remote-tracking refs, or commit history.
- Risk → safer choice: distinguish local cleanup from shared-history changes, and recognize when
restore,revert,reset,reflog, or a force push needs extra care. - Output → next step: read common status, diff, log, bisect, stash, branch, tag, and worktree results well enough to continue.
The sequence starts with repository setup and observation, moves through staging and commits, then adds branches, remotes, integration, history, debugging, undo, and recovery. Related prompt directions are separated so the neighboring card doesn't give away the answer.
This deck covers 36 useful top-level commands with modern porcelain such as git switch and git restore. Common older git checkout and git reset <path> forms appear only as compatibility notes. It excludes hosting-service pull requests, GUIs, credentials, server administration, most low-level plumbing commands, hooks, signing, Git LFS, submodules, partial clones, custom aliases, and exhaustive option catalogs. The practical low-level exceptions are git ls-files, git merge-base, and git rev-parse, which support everyday inspection and comparison tasks.
CC0 applies to the independently authored questions, answers, organization, metadata, and generated cover only to the extent applicable rights exist; it doesn't license Git facts, documentation, names, or trademarks.
Facts and examples were checked against the current official Git documentation and executed in disposable repositories with Git 2.50.1. This is an independent, unofficial educational deck. It isn't affiliated with or endorsed by the Git Project or Software Freedom Conservancy. No documentation prose, logos, command tables, competitor cards, or assessment questions were copied.
Tämän pakan kortit
Kortti 1
Kysymys
Initialize the current directory as a Git repository.
Vastaus
git initcreates the repository metadata in the current directory.git initIt doesn't add or commit the existing files.
Kortti 2
Kysymys
Set the commit email for only the current repository.
Vastaus
git config user.email dev@example.comsets a repository-local value.git config user.email dev@example.comOmitting
--globalkeeps other repositories unchanged.Kortti 3
Kysymys
Open the full manual for
git status.Vastaus
git help statusopens the command's manual.git help statusUse
git status -hwhen you only need the short option summary in the terminal.Kortti 4
Kysymys
Copy
../origin.gitinto a new local directory namedproject.Vastaus
git clone ../origin.git projectcreates the local clone inproject.git clone ../origin.git projectThe clone normally configures the source as the
originremote.Kortti 5
Kysymys
Show tracked changes that haven't been staged.
Vastaus
git diffshows the working-tree changes relative to the index.git diffNew untracked files don't appear until Git knows about them.
Kortti 6
Kysymys
Stage
notes.txtfor the next commit.Vastaus
git add notes.txtcopies the path's current content into the index.git add notes.txtLater edits to the file stay unstaged until you add them too.
Kortti 7
Kysymys
Inspect which changes are staged, unstaged, or untracked.
Vastaus
git statuscompares the working tree and index withHEAD.git statusIt reads repository state; it doesn't modify files or history.
Kortti 8
Kysymys
Record the staged snapshot with the message
Add notes.Vastaus
git commit -m "Add notes"creates a commit from the index.git commit -m "Add notes"Unstaged changes aren't included.
Kortti 9
Kysymys
Delete the tracked file
obsolete.txtand stage that deletion.Vastaus
git rm obsolete.txtremoves the file and stages the removal.git rm obsolete.txtCommit afterward to record the deletion in history.
Kortti 10
Kysymys
Rename tracked
old-name.txttonotes.txtand stage the change.Vastaus
git mv old-name.txt notes.txtmoves the path and updates the index.git mv old-name.txt notes.txtGit records snapshots, so it detects the rename from the resulting content when useful.
Kortti 11
Kysymys
List local branches and show which one is current.
Vastaus
git branchlists local branches and marks the current one with*.git branchIt doesn't switch branches.
Kortti 12
Kysymys
Switch the working tree to the existing branch
feature/login.Vastaus
git switch feature/loginswitches to that branch.git switch feature/loginGit updates the index and working tree, and refuses if the switch would overwrite local work. Older instructions often use
git checkoutfor branch switching;switchstates the intent more clearly.Kortti 13
Kysymys
Show every configured remote with its fetch and push URL.
Vastaus
git remote -vlists remote names and URLs.git remote -vA remote name such as
originis a local shortcut, not a special server type.Kortti 14
Kysymys
Read a compact one-line commit history.
Vastaus
git log --onelineprints one abbreviated entry per commit.git log --onelineThe newest reachable commit appears first.
Kortti 15
Kysymys
Discard unstaged edits to tracked
notes.txt.Vastaus
git restore notes.txtreplaces the working-tree file with the indexed version.git restore notes.txtThis is destructive for those unstaged edits. Check
git diff -- notes.txtfirst when unsure.Kortti 16
Kysymys
Clone
../origin.gitwhile naming the local directorysandbox.Vastaus
git clone ../origin.git sandboxseparates the source location from the local directory name.git clone ../origin.git sandboxRun it from the parent directory where
sandboxshould be created.Kortti 17
Kysymys
Read the effective commit email in the current repository.
Vastaus
git config --get user.emailprints the selected configuration value.git config --get user.emailRepository-local configuration overrides a global value.
Kortti 18
Kysymys
Get a compact status that still shows branch information.
Vastaus
git status --short --branchprints the branch line plus two-column path states.git status --short --branchThe left column describes the index; the right column describes the working tree.
Kortti 19
Kysymys
Review what is staged for the next commit.
Vastaus
git diff --stagedcompares the index withHEAD.git diff --staged--cachedis the common equivalent spelling.Kortti 20
Kysymys
Interactively stage selected hunks from
notes.txt.Vastaus
git add -p notes.txtlets you accept or reject each patch hunk.git add -p notes.txtThis is useful when one file contains changes for more than one commit.
Kortti 21
Kysymys
Open the configured editor to write a commit message for the staged snapshot.
Vastaus
git commitopens the commit-message editor.git commitGit still commits only the staged content.
Kortti 22
Kysymys
Stop tracking
local.envbut keep the file in the working tree.Vastaus
git rm --cached local.envstages removal from the index without deleting the local file.git rm --cached local.envAdd the path to an ignore rule if it shouldn't be staged again.
Kortti 23
Kysymys
Create
feature/loginat the current commit without switching to it.Vastaus
git branch feature/logincreates the branch reference.git branch feature/loginUse
git switch -c feature/loginwhen you want to create and switch in one step.Kortti 24
Kysymys
Add
../upstream.gitas a remote namedupstream.Vastaus
git remote add upstream ../upstream.gitstores that remote configuration.git remote add upstream ../upstream.gitIt doesn't fetch any refs until you run
git fetch upstream.Kortti 25
Kysymys
View a compact decorated commit graph across all local refs.
Vastaus
git log --oneline --graph --decorate --allcombines history, topology, and ref names.git log --oneline --graph --decorate --allIt is a read-only way to understand how branches relate.
Kortti 26
Kysymys
Inspect the current commit's metadata and patch.
Vastaus
git show HEADdisplays the commit and its changes.git show HEADReplace
HEADwith another revision when needed.Kortti 27
Kysymys
Create
feature/searchat the current commit and switch to it.Vastaus
git switch -c feature/searchcreates and checks out the branch.git switch -c feature/searchNew commits now advance
feature/search.Kortti 28
Kysymys
List the paths currently known to the index.
Vastaus
git ls-filesprints tracked and staged paths.git ls-filesIt is more precise than a filesystem listing when you need Git's view.
Kortti 29
Kysymys
Refresh remote-tracking refs from
originwithout integrating them.Vastaus
git fetch origindownloads objects and updatesorigin/*refs.git fetch originYour current branch and working tree stay in place.
Kortti 30
Kysymys
Unstage
notes.txtwhile keeping its working-tree edits.Vastaus
git restore --staged notes.txtrestores the index entry fromHEADby default.git restore --staged notes.txtThe file's edited content remains in the working tree.
Kortti 31
Kysymys
Temporarily store tracked work with the label
WIP login.Vastaus
git stash push -m "WIP login"saves tracked staged and unstaged changes, then cleans them from the worktree.git stash push -m "WIP login"Untracked files stay put unless you add
-u.Kortti 32
Kysymys
Check how the current branch differs from its configured upstream.
Vastaus
git status --branchreports ahead, behind, or diverged state when an upstream exists.git status --branchIt doesn't contact the remote, so fetch first when freshness matters.
Kortti 33
Kysymys
Compare the snapshots at
mainandfeature/login.Vastaus
git diff main feature/loginshows changes needed to turn the first tree into the second.git diff main feature/loginThis compares the two named tips, not their merge base.
Kortti 34
Kysymys
Stage all additions, modifications, and deletions in the current repository.
Vastaus
git add -Aupdates the index for every path in scope.git add -AReview
git diff --stagedbefore committing a broad change.Kortti 35
Kysymys
Replace the current local commit with a corrected snapshot but keep its message.
Vastaus
git commit --amend --no-editcreates a replacement commit from the current index.git commit --amend --no-editAmending rewrites the commit ID. Avoid it after sharing the commit unless the team expects a history update.
Kortti 36
Kysymys
Rename the current branch to
feature/auth.Vastaus
git branch -m feature/authrenames the checked-out branch.git branch -m feature/authIf the old name was already pushed, coordinate the remote rename separately.
Kortti 37
Kysymys
Return to the branch you were on immediately before this one.
Vastaus
git switch -switches to the previously checked-out branch.git switch -It is handy for moving between two branches.
Kortti 38
Kysymys
Integrate
feature/logininto the current branch.Vastaus
git merge feature/loginjoins the named branch into the current branch.git merge feature/loginThe result may be a fast-forward, merge commit, or conflict, depending on history and options.
Kortti 39
Kysymys
Fetch only the
mainbranch fromorigin.Vastaus
git fetch origin maindownloads that branch and records the fetched tip inFETCH_HEAD.git fetch origin mainIt doesn't merge or move your current branch.
Kortti 40
Kysymys
Update the current branch only when the remote change can fast-forward it.
Vastaus
git pull --ff-onlyfetches, then refuses to create a merge commit or rebase.git pull --ff-onlyA refusal leaves the divergent histories for you to inspect.
Kortti 41
Kysymys
Push the current branch
feature/logintoorigin.Vastaus
git push origin feature/loginupdates the same-named remote branch.git push origin feature/loginIt doesn't configure an upstream unless your settings do that automatically.
Kortti 42
Kysymys
Read commits that changed
notes.txt.Vastaus
git log -- notes.txtlimits history to commits affecting that path.git log -- notes.txtThe
--separates revisions and options from the path.Kortti 43
Kysymys
Print
notes.txtexactly as it exists inHEADwithout switching commits.Vastaus
git show HEAD:notes.txtreads the blob at that revision and path.git show HEAD:notes.txtThis doesn't modify the working-tree file.
Kortti 44
Kysymys
Search tracked working-tree files for the text
TODO, including unstaged edits.Vastaus
git grep TODOsearches tracked files in the working tree, including their unstaged content.git grep TODOIt skips untracked files by default.
Kortti 45
Kysymys
Show the commit and author associated with each line of
notes.txt.Vastaus
git blame notes.txtannotates each line with its last recorded change.git blame notes.txtUse it as a history lead, not as proof that one person owns the current behavior.
Kortti 46
Kysymys
Move the current branch back one commit while keeping the changes unstaged.
Vastaus
git reset HEAD~1performs the default mixed reset.git reset HEAD~1It rewrites the local branch tip but leaves the changed files in the working tree.
Kortti 47
Kysymys
Stash tracked and untracked work together with the label
WIP search.Vastaus
git stash push -u -m "WIP search"includes untracked files.git stash push -u -m "WIP search"Ignored files still stay out unless you deliberately use the stronger
--alloption.Kortti 48
Kysymys
List local tags whose names start with
v1..Vastaus
git tag --list "v1.*"filters the local tag names.git tag --list "v1.*"Listing tags doesn't contact a remote.
Kortti 49
Kysymys
Resolve
HEADto its full object ID.Vastaus
git rev-parse HEADprints the object name selected by the revision.git rev-parse HEADThis is useful in scripts that need an exact commit ID.
Kortti 50
Kysymys
Review prose edits as changed words instead of whole lines.
Vastaus
git diff --word-diffhighlights inline word-level changes.git diff --word-diffIt changes the display only; repository state stays untouched.
Kortti 51
Kysymys
Integrate
feature/loginonly if the current branch can fast-forward.Vastaus
git merge --ff-only feature/loginrefuses histories that require a merge commit.git merge --ff-only feature/loginThe refusal is a safety check, not a partial merge.
Kortti 52
Kysymys
Fetch
originand remove remote-tracking refs that the remote no longer has.Vastaus
git fetch --prune originrefreshes refs and prunes staleorigin/*names.git fetch --prune originIt doesn't delete local branches.
Kortti 53
Kysymys
List commits reachable from
feature/loginbut not frommain.Vastaus
git log main..feature/login --onelineshows that one-sided revision range.git log main..feature/login --onelineThe order around
..matters.Kortti 54
Kysymys
Replace working-tree
notes.txtwith its version fromHEAD~1.Vastaus
git restore --source=HEAD~1 notes.txtcopies the older blob into the working tree.git restore --source=HEAD~1 notes.txtThis overwrites current unstaged edits to
notes.txt. Diff, copy, or otherwise protect wanted edits first; then review and stage the restored version if you want to keep it.Kortti 55
Kysymys
Create branch
hotfixin an additional working tree at../hotfix.Vastaus
git worktree add ../hotfix -b hotfixcreates the branch and checks it out there.git worktree add ../hotfix -b hotfixThe original working tree stays on its current branch.
Kortti 56
Kysymys
Push
feature/loginand configureorigin/feature/loginas its upstream.Vastaus
git push -u origin feature/loginpushes the branch and records upstream tracking.git push -u origin feature/loginLater
git status,git pull, andgit pushcan use that relationship.Kortti 57
Kysymys
Follow likely moved or copied lines while blaming
notes.txt.Vastaus
git blame -M -C notes.txtadds move and copy detection heuristics.git blame -M -C notes.txtThe result is still a clue for investigation, not an ownership verdict.
Kortti 58
Kysymys
Replay the current branch's local commits on top of
main.Vastaus
git rebase mainrewrites those commits onto the new base.git rebase mainUse it on unshared work, or coordinate before rewriting commits other people may use.
Kortti 59
Kysymys
Move the branch back one commit while keeping all reverted changes staged.
Vastaus
git reset --soft HEAD~1movesHEADbut leaves the index and working tree intact.git reset --soft HEAD~1This rewrites the local branch tip and is best kept to unshared history.
Kortti 60
Kysymys
Create an annotated release tag
v1.0.0at the current commit.Vastaus
git tag -a v1.0.0 -m "Release 1.0.0"creates a tag object with a message.git tag -a v1.0.0 -m "Release 1.0.0"Tags aren't pushed automatically unless you push them explicitly.
Kortti 61
Kysymys
Start a regression search with
HEADknown bad andHEAD~4known good.Vastaus
git bisect start, followed by bad and good boundaries, begins binary search through the range.git bisect start git bisect bad HEAD git bisect good HEAD~4Git checks out a midpoint for you to test.
Kortti 62
Kysymys
Fetch the upstream branch, then replay local commits on top of it.
Vastaus
git pull --rebasecombines fetch with a rebase-based integration.git pull --rebaseIt rewrites local commits, so inspect the branch and keep shared-history expectations in mind.
Kortti 63
Kysymys
Commit the staged update as
Update noteswhile leaving unstaged edits out.Vastaus
git commit -m "Update notes"records the index, not every working-tree edit.git commit -m "Update notes"Review both
git diff --stagedandgit diffwhen the split matters.Kortti 64
Kysymys
Undo the current non-merge commit with a new commit instead of moving the branch backward.
Vastaus
git revert HEADapplies the inverse of the current non-merge commit and records it as a new commit.git revert HEADFor a merge commit, inspect its parents and use the mainline form taught later:
git revert -m <parent-number> <merge-commit>. Revert preserves shared history, which usually makes it safer than reset for published commits.Kortti 65
Kysymys
Delete the fully merged local branch
feature/login.Vastaus
git branch -d feature/logindeletes the branch only when Git considers it merged.git branch -d feature/loginThe lowercase
-dguard helps prevent accidental loss of unmerged branch tips.Kortti 66
Kysymys
Inspect
HEAD~1without moving any branch name.Vastaus
git switch --detach HEAD~1checks out the commit in detached-HEAD mode.git switch --detach HEAD~1Create a branch before leaving if you make commits you want to keep.
Kortti 67
Kysymys
Find one best common ancestor of
mainandfeature/login.Vastaus
git merge-base main feature/loginprints one best merge base.git merge-base main feature/loginCriss-cross histories can have multiple equally best bases. Use
git merge-base --all main feature/loginwhen every best base matters; without--all, Git chooses one unspecified best base.Kortti 68
Kysymys
Print the top-level directory of the current working tree.
Vastaus
git rev-parse --show-toplevelresolves the repository root path.git rev-parse --show-toplevelIt fails outside a working tree, which is useful in scripts that require one.
Kortti 69
Kysymys
Inspect recent local movements of
HEAD.Vastaus
git reflog --onelineshows the local reference-update history in compact form.git reflog --onelineIt can reveal commits hidden by reset or rebase while their objects still exist.
Kortti 70
Kysymys
List stashes, then summarize the newest stash's changed paths.
Vastaus
git stash listnames the entries, andgit stash show --stat stash@{0}summarizes the newest one.git stash list git stash show --stat stash@{0}Neither command removes or applies the stash.
Kortti 71
Kysymys
Apply the tip commit from
feature/loginwithout conflicts and record where it came from.Vastaus
git cherry-pick -x feature/loginapplies the commit and, when it applies without conflicts, adds a source-commit line to the message.git cherry-pick -x feature/loginUse
-xwhen the trace is useful and the picked commit is public enough to name.Kortti 72
Kysymys
Preview which untracked files under
scratch/Git would delete.Vastaus
git clean -nd -- scratch/performs a scoped dry run.git clean -nd -- scratch/Run the preview before replacing
-nwith-f; ignored files aren't included here.Kortti 73
Kysymys
Identify conflicted paths after a merge stops.
Vastaus
git status --shortmarks unmerged paths with combinations such asUU.git status --shortResolve each path, stage the result, then complete the merge commit—or abort the merge.
Kortti 74
Kysymys
Continue a rebase after resolving and staging its conflicts.
Vastaus
git rebase --continuerecords the resolved step and moves to the next commit.git rebase --continueIf the resolution is wrong or the rewrite is no longer wanted, abort instead.
Kortti 75
Kysymys
List every working tree attached to the repository.
Vastaus
git worktree listshows each path, checked-out commit, and branch when attached.git worktree listA branch normally can't be checked out in two worktrees at once.
Kortti 76
Kysymys
Fetch and integrate the upstream with merge semantics rather than rebase.
Vastaus
git pull --no-rebasefetches, then merges the selected upstream.git pull --no-rebaseUse an explicit policy so the integration behavior isn't a surprise.
Kortti 77
Kysymys
Interactively discard selected unstaged hunks from
notes.txt.Vastaus
git restore -p notes.txtasks which working-tree hunks to restore from the index.git restore -p notes.txtAccepted hunks are discarded, so review each prompt carefully.
Kortti 78
Kysymys
Delete the remote branch
feature/loginfromorigin.Vastaus
git push origin --delete feature/loginremoves that remote ref.git push origin --delete feature/loginIt doesn't delete anyone's local branch or existing commits immediately.
Kortti 79
Kysymys
Mark
HEAD~4as a known good boundary during a bisect session.Vastaus
git bisect good HEAD~4tells Git that the named commit doesn't contain the bug.git bisect good HEAD~4Git uses good and bad boundaries to choose the next midpoint.
Kortti 80
Kysymys
Delete the local tag
v1.0.0.Vastaus
git tag -d v1.0.0removes the local tag reference.git tag -d v1.0.0A remote copy, if any, needs a separate remote update.
Kortti 81
Kysymys
Move the branch back one commit and discard the index and working-tree changes.
Vastaus
git reset --hard HEAD~1makes the branch, index, and tracked working tree matchHEAD~1.git reset --hard HEAD~1This is destructive. It can also delete or overwrite untracked files or directories that obstruct paths tracked by the target commit. Confirm the target and move wanted work first.
Kortti 82
Kysymys
Give the current commit a human-readable name based on reachable tags.
Vastaus
git describe --tags --alwaysuses the nearest tag when possible and falls back to an object name.git describe --tags --alwaysIt reads history without creating or moving a tag.
Kortti 83
Kysymys
Continue a cherry-pick after resolving and staging its conflicts.
Vastaus
git cherry-pick --continuefinishes the current picked commit.git cherry-pick --continueGit may continue to another commit if the original request included a sequence.
Kortti 84
Kysymys
Delete ordinary, non-ignored untracked files and directories only under
scratch/.Vastaus
git clean -fd -- scratch/removes ordinary, non-ignored untracked files and directories under that path.git clean -fd -- scratch/It leaves ignored content and nested Git repositories in place. This can't be recovered through normal Git history, so run the matching dry run first.
Kortti 85
Kysymys
Apply the inverse of the current non-merge commit to the index and working tree without committing yet.
Vastaus
git revert --no-commit HEADprepares the inverse of the current non-merge commit for inspection.git revert --no-commit HEADFor a merge commit, inspect its parents and use the mainline form taught later:
git revert -m <parent-number> <merge-commit>. You can combine or edit the prepared change before creating a commit.Kortti 86
Kysymys
Apply the newest stash while keeping it in the stash list.
Vastaus
git stash apply stash@{0}reapplies the entry without dropping it.git stash apply stash@{0}Use
poponly when you want a successful apply to remove the entry automatically.Kortti 87
Kysymys
Create branch
recoveredat the previous recorded location ofHEAD.Vastaus
git branch recovered HEAD@{1}gives the reflog entry a durable branch name.git branch recovered HEAD@{1}Inspect the entry first; reflog positions change as new reference updates happen.
Kortti 88
Kysymys
Abandon the current conflicted merge and return to its pre-merge state.
Vastaus
git merge --abortstops the in-progress merge.git merge --abortUncommitted changes that predated the merge can make exact reconstruction harder, so start risky merges from a clear state.
Kortti 89
Kysymys
Unstage
notes.txtwith the older path-specific reset form.Vastaus
git reset HEAD -- notes.txtresets only the index entry and keeps working-tree edits.git reset HEAD -- notes.txtModern instructions usually prefer
git restore --staged notes.txtfor this job.Kortti 90
Kysymys
Remove the clean linked working tree at
../hotfix.Vastaus
git worktree remove ../hotfixremoves that working tree and its administrative record.git worktree remove ../hotfixIt refuses a dirty working tree unless you force it; inspect and save work instead of forcing by habit.
Kortti 91
Kysymys
Force-update
feature/loginonly if its remote tip matches your localorigin/feature/loginexpectation.Vastaus
git push --force-with-lease origin feature/logincompares the remote branch with the local remote-tracking ref before force-updating.git push --force-with-lease origin feature/loginBackground or automatic fetches can move that local ref and weaken the check. Inspect the fetched tip, coordinate the rewrite, and use an explicit
<ref>:<expect>lease when exact protection matters.Kortti 92
Kysymys
Abandon the current rebase and restore the branch to its pre-rebase state.
Vastaus
git rebase --abortstops the rewrite and restores the original branch tip.git rebase --abortUse it when the conflict resolution or rewrite plan isn't worth continuing.
Kortti 93
Kysymys
Revert the current merge commit while keeping its first parent as the mainline.
Vastaus
git revert -m 1 HEADcreates an inverse change relative to parent 1.git revert -m 1 HEADChoosing the wrong mainline changes the meaning, so inspect the merge's parents first. Its ancestors remain integrated in history, which means a later merge may not restore the reverted tree changes automatically.
Kortti 94
Kysymys
End a bisect session and return to the branch or commit checked out before it.
Vastaus
git bisect resetrestores the pre-bisect checkout.git bisect resetRun it after identifying the first bad commit or when abandoning the search.
Kortti 95
Kysymys
Read the reflog specifically for
HEAD.Vastaus
git reflog show HEADdisplays local movements recorded forHEAD.git reflog show HEADReflogs are local recovery records; they aren't a shared remote audit log.
Kortti 96
Kysymys
Abandon the current conflicted cherry-pick.
Vastaus
git cherry-pick --abortrestores the state from before the cherry-pick sequence.git cherry-pick --abortUse it instead of stacking unrelated cleanup commands onto a failed pick.
Kortti 97
Kysymys
Interactively edit the last three local commits before sharing them.
Vastaus
git rebase -i HEAD~3opens a plan for reordering, editing, squashing, or dropping those commits.git rebase -i HEAD~3Every changed commit gets a new ID. Keep interactive rebase to unshared work unless everyone has coordinated.
Kortti 98
Kysymys
Run
./test.shautomatically at each midpoint of an active bisect.Vastaus
git bisect run ./test.shclassifies commits from the script's exit status.git bisect run ./test.shThe test must be deterministic: exit 0 for good, 1–127 except 125 for bad, and 125 to skip an untestable commit.
98 korttia
Git Commands Flashcards: Everyday Workflow, Branching & Recovery
Nibomo avautuu, jotta voit aloittaa opiskelun.