> For the complete documentation index, see [llms.txt](https://dbh-ict.gitbook.io/inleiding-git-github/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://dbh-ict.gitbook.io/inleiding-git-github/git-cheat-sheet.md).

# Git Cheat Sheet

#### Create

* Clone and Existing Repository

  ```
  $ git clone ssh://user@domain.com/repo.git
  ```
* Create a new local repository

  ```
  $ git init
  ```
* Clone and Existing Repository

  ```
  $ git clone ssh://user@domain.com/repo.git
  ```
* Clone and Existing Repository

  ```
  $ git clone ssh://user@domain.com/repo.git
  ```

#### Local Changes

* Changed files in your working directory

  ```
  $ git status
  ```
* Changes to tracked files

  ```
  $ git diff
  ```
* Add all current changes to the next commit

  ```
  $ git add .
  ```
* Add some changes in \<file> to the next commit

  ```
  $ git add -p <file>
  ```
* Commit all local changes in tracked files

  ```
  $ git commit -a
  ```
* Commit previously staged changes

  ```
  $ git add -p <file>
  ```
* Add some changes in to the next commit

  ```
  $ git commit
  ```
* Change the last commit\
  *Don‘t amend published commits!*

  ```
  $ git commit --amend
  ```

#### Branching & Tags

* List all existing branches

  ```
  $ git branch
  ```
* Switch HEAD branch

  ```
  $ git checkout <branch>
  ```
* Create a new branch based on your current HEAD

  ```
  $ git branch <new-branch> 
  ```
* Create a new tracking branch based on a remote branch

  ```
  $ git checkout --track <remote/branch>
  ```
* Delete a local branch

  ```
  $ git branch -d <branch>
  ```
* Mark the current commit with a tag

  ```
  $ git tag <tag-name>
  ```

#### Update & Publish

* List all currently configured remotes

  ```
  $ git remote -v
  ```
* Show information about a remote

  ```
  $ git remote show <remote>
  ```
* Add new remote repository, named \<remote>

  ```
  $ git remote add <remote> <url> 
  ```
* Download all changes from \<remote>, but don‘t integrate into HEAD

  ```
  $ git fetch <remote>
  ```
* Download changes and directly merge/integrate into HEAD

  ```
  $ git pull <remote> <branch>
  ```
* Publish local changes on a remote

  ```
  $ git push <remote> <branch>
  ```
* Delete a branch on the remote

  ```
  $ git branch -dr <remote/branch>
  ```
* Publish your tags

  ```
  $ git push --tags
  ```

#### Merge & Rebase

* Merge \<branch> into your current HEAD

  ```
  $ git merge <branch>
  ```
* Rebase your current HEAD onto \<branch>\
  *Don‘t rebase published commits!*

  ```
  $ git rebase <branch>
  ```
* Abort a rebase

  ```
  $ git rebase --abort
  ```
* Continue a rebase after resolving conflicts

  ```
  $ git rebase --continue
  ```
* Use your configured merge tool to solve conflicts

  ```
  $ git mergetool
  ```
* Use your editor to manually solve conflicts

  ```
  $ git add <resolved-file>
  ```
* After resolving mark file as resolved

  ```
  $ git rm <resolved-file>
  ```

#### Undo

* Discard all local changes in your working directory

  ```
  $ git reset --hard HEAD
  ```
* Discard local changes in a specific file

  ```
  $ git checkout <file>
  ```
* Revert a commit (by producing a new commit with contrary changes)

  ```
  $ git revert <commit>
  ```
* Reset your HEAD pointer to a previous commit & discard all changes since then

  ```
  $ git reset --hard <commit>
  ```
* Reset your HEAD pointer to a previous commit & preserve all changes as unstaged changes

  ```
  $ git reset <commit>
  ```
* Reset your HEAD pointer to a previous commit & preserve uncommitted local changes

  ```
  $ git reset --keep <commit>
  ```

## Git ignore patronen

| Patroon                                                                             | Voorbeeldovereenkomsten                                                                                                                                     | Uitleg\*                                                                                                                                                                                                                                                                                           |
| ----------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `**/logs`                                                                           | <p><code>logs/debug.log</code><br><code>logs/monday/foo.bar</code><br><code>build/logs/debug.log</code></p>                                                 | Je kunt een patroon vooraf laten gaan door een dubbele asterisk zodat overeenkomsten worden gezocht met mappen in de gehele repository.                                                                                                                                                            |
| `**/logs/debug.log`                                                                 | <p><code>logs/debug.log</code><br><code>build/logs/debug.log</code><br><em>maar niet</em><br><code>logs/build/debug.log</code></p>                          | Je kunt ook een dubbele asterisk gebruiken om bestanden te matchen op basis van hun naam en de naam van hun bovenliggende map.                                                                                                                                                                     |
| `*.log`                                                                             | <p><code>debug.log</code><br><code>foo.log</code><br><code>.log</code><br><code>logs/debug.log</code></p>                                                   | Een asterisk is een jokerteken dat overeenkomt met nul of meer tekens.                                                                                                                                                                                                                             |
| <p><code>\*.log</code><br><code>!important.log</code></p>                           | <p><code>debug.log</code><br><code>trace.log</code><br><em>maar niet</em><br><code>important.log</code><br><code>logs/important.log</code></p>              | Door vooraan een uitroepteken te plaatsen, zal het patroon het negeren. Als een bestand overeenkomt met een patroon, maar *ook* met een ontkenningspatroon dat later in het bestand is gedefinieerd, wordt het niet genegeerd.                                                                     |
| <p><code>*.log</code><br><code>!important/*.log</code><br><code>trace.\*</code></p> | <p><code>debug.log</code><br><code>important/trace.log</code><br><em>maar niet</em><br><code>important/debug.log</code></p>                                 | Patronen die ná een ontkenningspatroon zijn gedefinieerd, zullen alle eerder ontkende bestanden opnieuw negeren.                                                                                                                                                                                   |
| `/debug.log`                                                                        | <p><code>debug.log</code><br><em>maar niet</em><br><code>logs/debug.log</code></p>                                                                          | Door vooraan een slash toe te voegen, worden alleen bestanden in de hoofdmap van de repository gezocht.                                                                                                                                                                                            |
| `debug.log`                                                                         | <p><code>debug.log</code><br><code>logs/debug.log</code></p>                                                                                                | Patronen komen standaard overeen met bestanden in een map                                                                                                                                                                                                                                          |
| `debug?.log`                                                                        | <p><code>debug0.log</code><br><code>debugg.log</code><br><em>maar niet</em><br><code>debug10.log</code></p>                                                 | Een vraagteken komt overeen met precies één karakter.                                                                                                                                                                                                                                              |
| `debug[0-9].log`                                                                    | <p><code>debug0.log</code><br><code>debug1.log</code><br><em>maar niet</em><br><code>debug10.log</code></p>                                                 | Er kunnen ook blokhaken worden gebruikt om een enkel teken uit een bepaalde reeks te matchen.                                                                                                                                                                                                      |
| `debug[01].log`                                                                     | <p><code>debug0.log</code><br><code>debug1.log</code><br><em>maar niet</em><br><code>debug2.log</code><br><code>debug01.log</code></p>                      | Blokhaken komen overeen met één teken uit de opgegeven set.                                                                                                                                                                                                                                        |
| `debug[!01].log`                                                                    | <p><code>debug2.log</code><br><em>maar niet</em><br><code>debug0.log</code><br><code>debug1.log</code><br><code>debug01.log</code></p>                      | Een uitroepteken kan worden gebruikt voor overeenkomsten met elk teken, behalve één uit de opgegeven set.                                                                                                                                                                                          |
| `debug[a-z].log`                                                                    | <p><code>debuga.log</code><br><code>debugb.log</code><br><em>maar niet</em><br><code>debug1.log</code></p>                                                  | Reeksen kunnen numeriek of alfabetisch zijn.                                                                                                                                                                                                                                                       |
| `Logboeken`                                                                         | <p><code>logs</code><br><code>logs/debug.log</code><br><code>logs/latest/foo.bar</code><br><code>build/logs</code><br><code>build/logs/debug.log</code></p> | Als je geen slash voor de naam plaatst, zoekt het patroon zowel bestanden als de inhoud van mappen met die naam. In het voorbeeld links worden zowel mappen als bestanden met de naam *logs* genegeerd.                                                                                            |
| logs/                                                                               | <p><code>logs/debug.log</code><br><code>logs/latest/foo.bar</code><br><code>build/logs/foo.bar</code><br><code>build/logs/latest/debug.log</code></p>       | Het toevoegen van een slash vooraan geeft aan dat het patroon een map is. De volledige inhoud van elke map in de repository die overeenkomt met die naam — inclusief alle bestanden en submappen — wordt genegeerd.                                                                                |
| <p><code>logs/</code><br><code>!logs/important.log</code></p>                       | <p><code>logs/debug.log</code><br><code>logs/important.log</code></p>                                                                                       | <p>Wacht even! Zou <code>logs/important.log</code> niet moeten worden genegeerd in het voorbeeld links?<br><br>Nee hoor! Vanwege een prestatiegerelateerde eigenaardigheid in Git kun je een bestand dat wordt genegeerd <em>niet</em> negeren vanwege een patroon dat overeenkomt met een map</p> |
| `logs/**/debug.log`                                                                 | <p><code>logs/debug.log</code><br><code>logs/monday/debug.log</code><br><code>logs/monday/pm/debug.log</code></p>                                           | Een dubbele asterisk komt overeen met nul of meer mappen.                                                                                                                                                                                                                                          |
| `logs/*day/debug.log`                                                               | <p><code>logs/monday/debug.log</code><br><code>logs/tuesday/debug.log</code><br><em>maar niet</em><br><code>logs/latest/debug.log</code></p>                | Jokertekens kunnen ook worden gebruikt in mapnamen.                                                                                                                                                                                                                                                |
| `logs/debug.log`                                                                    | <p><code>logs/debug.log</code><br><em>maar niet</em><br><code>debug.log</code><br><code>build/logs/debug.log</code></p>                                     | Patronen die een bestand in een bepaalde map opgeven, zijn relatief ten opzichte van de hoofdmap van de repository. (Je kunt desgewenst een slash vooraan plaatsen, maar die doet niets bijzonders.)                                                                                               |
