251 lines
6.2 KiB
Plaintext
251 lines
6.2 KiB
Plaintext
z1
|
||
Pewnie! Poniżej masz zwięzłe, „dla ucznia” instrukcje do tematu **2.2 Podstawy Gita – rejestrowanie zmian w repozytorium**. To jest gotowa ściąga + scenariusz ćwiczenia krok-po-kroku.
|
||
|
||
# 2.2 Rejestrowanie zmian w Git
|
||
|
||
## Cel
|
||
|
||
Nauczysz się:
|
||
|
||
* sprawdzać stan repozytorium,
|
||
* dodawać pliki do „poczekalni” (staging area),
|
||
* zatwierdzać (commitować) zmiany,
|
||
* ignorować niepotrzebne pliki,
|
||
* usuwać/zmieniać nazwy plików w projekcie pod kontrolą Gita,
|
||
* przeglądać różnice (diff) tego, co **poza** i **w** poczekalni.
|
||
|
||
---
|
||
|
||
## Słowniczek (bardzo krótko)
|
||
|
||
* **Śledzony (tracked)** – plik był w ostatnim commicie. Może być: niezmodyfikowany, zmodyfikowany, albo w poczekalni.
|
||
* **Nieśledzony (untracked)** – plik nowy dla Gita (nie był w ostatnim commicie).
|
||
* **Poczekalnia (staging area / index)** – lista zmian, które **wejdą do najbliższego commita**.
|
||
* **Commit** – zapisana migawka projektu z opisem.
|
||
|
||
---
|
||
|
||
## Najważniejsze polecenia (z przykładami)
|
||
|
||
### 1) Sprawdź status
|
||
|
||
```bash
|
||
git status
|
||
```
|
||
|
||
* Pokazuje gałąź, pliki **nieśledzone**, **zmodyfikowane** i **w poczekalni**.
|
||
|
||
### 2) Zacznij śledzić plik / dodaj do poczekalni
|
||
|
||
```bash
|
||
git add README # pojedynczy plik
|
||
git add . # wszystko z bieżącego katalogu (ostrożnie)
|
||
```
|
||
|
||
### 3) Zobacz różnice
|
||
|
||
* **Zmiany poza poczekalnią**:
|
||
|
||
```bash
|
||
git diff
|
||
```
|
||
|
||
* **Zmiany w poczekalni (wejdą do commita)**:
|
||
|
||
```bash
|
||
git diff --staged # to samo co: git diff --cached
|
||
```
|
||
|
||
### 4) Zatwierdź zmiany (commit)
|
||
|
||
```bash
|
||
git commit # otworzy edytor do wpisania wiadomości
|
||
git commit -m "Krótki, rzeczowy opis zmiany"
|
||
```
|
||
|
||
### 5) Pomiń poczekalnię dla śledzonych plików
|
||
|
||
> Działa **tylko** dla plików już śledzonych.
|
||
|
||
```bash
|
||
git commit -a -m "Szybki commit bez ręcznego git add"
|
||
```
|
||
|
||
### 6) Cofnij dodanie do poczekalni / porzuć zmiany w pliku
|
||
|
||
```bash
|
||
git reset HEAD <plik> # wyjmij plik z poczekalni (zostają zmiany na dysku)
|
||
git checkout -- <plik> # porzuć zmiany w pliku i przywróć wersję z HEAD
|
||
```
|
||
|
||
### 7) Ignoruj pliki – `.gitignore`
|
||
|
||
Utwórz plik `.gitignore` w katalogu projektu:
|
||
|
||
```gitignore
|
||
# przykłady:
|
||
*.o
|
||
*.a
|
||
*~
|
||
/TODO
|
||
build/
|
||
doc/*.txt
|
||
doc/**/*.txt
|
||
```
|
||
|
||
Zasady:
|
||
|
||
* `#` – komentarz
|
||
* `*` – dowolny ciąg znaków, `?` – jeden znak, `[abc]` – zestaw znaków
|
||
* `/` na końcu – katalog
|
||
* `!wzorzec` – zanegowanie (wyjątek od reguły)
|
||
|
||
### 8) Usuń plik z repo (i z dysku)
|
||
|
||
```bash
|
||
git rm PROJECTS.md
|
||
git commit -m "Usuń PROJECTS.md"
|
||
```
|
||
|
||
* Jeśli plik był już w poczekalni po modyfikacji – użyj `git rm -f`.
|
||
|
||
**Zostaw plik na dysku, ale przestań śledzić:**
|
||
|
||
```bash
|
||
git rm --cached duzy.log
|
||
```
|
||
|
||
### 9) Zmień nazwę/przenieś plik
|
||
|
||
```bash
|
||
git mv stara_nazwa nowa_nazwa
|
||
# równoważne ręcznie:
|
||
# mv stara_nazwa nowa_nazwa && git rm stara_nazwa && git add nowa_nazwa
|
||
```
|
||
|
||
---
|
||
|
||
## „Zwięzły status” – szybka legenda
|
||
|
||
```bash
|
||
git status -s
|
||
```
|
||
|
||
Przykład:
|
||
|
||
```
|
||
M README # M po prawej: zmieniony w katalogu roboczym
|
||
M lib/simplegit.rb # M po lewej: zmiana jest w poczekalni
|
||
A lib/git.rb # A w poczekalni (nowy plik dodany)
|
||
?? LICENSE.txt # plik nieśledzony
|
||
```
|
||
|
||
Dwukolumnowo: **lewa** = poczekalnia, **prawa** = katalog roboczy.
|
||
|
||
---
|
||
|
||
## Rekomendowany workflow (bezpieczny)
|
||
|
||
1. **Sprawdź status**: `git status`
|
||
2. **Obejrzyj różnice**: `git diff`
|
||
3. **Dodaj do poczekalni** konkretne pliki: `git add <plik>`
|
||
4. **Sprawdź co wejdzie**: `git diff --staged`
|
||
5. **Commit** z sensownym opisem: `git commit -m "…"`
|
||
6. **Powtórz** po kolejnych zmianach.
|
||
|
||
> Uwaga: jeżeli edytowałeś plik **po** `git add`, dodaj go **ponownie** (`git add <plik>`), inaczej commit nie uwzględni ostatniej poprawki!
|
||
|
||
---
|
||
|
||
## Najczęstsze błędy i szybkie naprawy
|
||
|
||
* „Commit nic nie zawiera” → zapomniałeś `git add`. Dodaj i powtórz.
|
||
* „Plik w poczekalni i jednocześnie zmodyfikowany” → dodałeś go, a potem znów zmieniłeś. Użyj:
|
||
|
||
* `git diff` (co jest **poza** poczekalnią),
|
||
* `git diff --staged` (co **wejdzie** do commita),
|
||
* i **ponownie** `git add <plik>`.
|
||
* „Przez pomyłkę dodałem śmieci” → dodaj do `.gitignore`, a plik wyjmij ze śledzenia: `git rm --cached <plik>`.
|
||
|
||
---
|
||
|
||
## Mini-ćwiczenie (15–20 min)
|
||
|
||
1. **Przygotuj repo**
|
||
|
||
```bash
|
||
git init git-lesson
|
||
cd git-lesson
|
||
echo "Witaj Git!" > README.md
|
||
git add README.md
|
||
git commit -m "Inicjalny commit z README"
|
||
```
|
||
|
||
2. **Dodaj nowy plik i przećwicz statusy**
|
||
|
||
```bash
|
||
echo "Zasady" > RULES.md
|
||
git status # zobaczysz ?? RULES.md
|
||
git add RULES.md
|
||
git status -s # powinno pokazać A RULES.md
|
||
git commit -m "Dodaj RULES.md"
|
||
```
|
||
|
||
3. **Modyfikacje + poczekalnia**
|
||
|
||
```bash
|
||
echo "Linia A" >> README.md
|
||
git diff # zobaczysz różnice poza poczekalnią
|
||
git add README.md
|
||
git diff --staged # zobaczysz różnice, które wejdą do commita
|
||
git commit -m "Uzupełnij README o Linię A"
|
||
```
|
||
|
||
4. **Zmiany po dodaniu do poczekalni**
|
||
|
||
```bash
|
||
echo "Linia B" >> README.md
|
||
git status # README pojawi się jednocześnie w staged i modified
|
||
git add README.md # dołóż najnowsze zmiany do poczekalni
|
||
git commit -m "Dodaj Linię B do README"
|
||
```
|
||
|
||
5. **.gitignore**
|
||
|
||
```bash
|
||
echo "*.log" > .gitignore
|
||
echo "debug.log" > debug.log
|
||
git status # debug.log powinien być ignorowany
|
||
git add .gitignore
|
||
git commit -m "Dodaj regułę ignorowania *.log"
|
||
```
|
||
|
||
6. **Usuwanie i zmiana nazwy**
|
||
|
||
```bash
|
||
git rm RULES.md
|
||
git commit -m "Usuń plik RULES.md"
|
||
|
||
git mv README.md README
|
||
git commit -m "Zmień nazwę README.md -> README"
|
||
```
|
||
|
||
> Na koniec `git log --oneline` – sprawdź historię swoich commitów.
|
||
|
||
---
|
||
|
||
## Krótka ściąga (do druku)
|
||
|
||
* **Stan**: `git status` / `git status -s`
|
||
* **Różnice**: `git diff` (poza poczekalnią), `git diff --staged` (wejdą do commita)
|
||
* **Dodanie**: `git add <plik>` / `git add .`
|
||
* **Commit**: `git commit -m "Opis"` / `git commit -a -m "Opis"` (tylko śledzone)
|
||
* **Wyjęcie z poczekalni**: `git reset HEAD <plik>`
|
||
* **Porzucenie zmian w pliku**: `git checkout -- <plik>`
|
||
* **Ignorowanie**: `.gitignore`
|
||
* **Usuwanie**: `git rm <plik>` / `git rm --cached <plik>`
|
||
* **Zmiana nazwy**: `git mv stara nowa`
|
||
|
||
Chcesz, żebym przerobił to na jedną stronę A4 (PDF) dla uczniów z miejscem na odhaczenie kroków i mini-quiz na końcu?
|
||
|