Kontrola Wersji: Kompletny Przewodnik po Git dla Początkujących Programistów

Wprowadzenie

W świecie programowania Git stał się jednym z najważniejszych narzędzi, bez którego trudno sobie wyobrazić efektywną pracę nad kodem. Niezależnie od tego, czy tworzysz prosty projekt hobbystyczny, czy współpracujesz nad złożoną aplikacją w zespole, umiejętność korzystania z Git pozwala zachować porządek, kontrolować zmiany i łatwo współpracować z innymi.

W tym artykule wprowadzimy Cię w podstawy Git, przedstawiając jego kluczowe koncepcje i narzędzia, które są nieodzowne zarówno dla początkujących programistów, jak i bardziej doświadczonych deweloperów. Zaczynamy!

Co to jest Git?

Git to rozproszony system kontroli wersji, który rewolucjonizuje sposób, w jaki zarządzamy kodem w projektach programistycznych. Umożliwia śledzenie zmian w plikach, współpracę w zespołach i łatwe zarządzanie różnymi wersjami projektu. Jest niezwykle wszechstronny, a jego podstawowe koncepcje są kluczowe do zrozumienia.

Oto kilka kluczowych pojęć, które pomogą Ci rozpocząć:

• Repozytorium: Centralne miejsce, w którym przechowywany jest projekt wraz z całą historią zmian.
• Commit: Pojedynczy zapis zmian dokonanych w projekcie, który pozwala odtworzyć jego stan w danym momencie.
• Branch (gałąź): Oddzielna linia rozwoju projektu, umożliwiająca pracę nad nowymi funkcjami lub poprawkami bez wpływu na główną wersję.
• Merge (scalanie): Proces łączenia zmian dokonanych w różnych gałęziach, który synchronizuje efekty pracy zespołu.

Dzięki Git możesz bez obaw eksperymentować z kodem, cofnąć się do poprzedniej wersji projektu, a także efektywnie współpracować z innymi programistami na całym świecie.

Podstawowe komendy Git

Poznaj najważniejsze komendy Git, które stanowią fundament codziennej pracy z tym systemem:

1. Inicjalizacja repozytorium

git init

Ta komenda tworzy nowe repozytorium Git w bieżącym katalogu. Stosuje się ją przy rozpoczynaniu pracy nad nowym projektem.

2. Sprawdzanie statusu

git status

Wyświetla aktualny stan repozytorium, w tym informacje o plikach zmodyfikowanych, dodanych do indeksu lub usuniętych.

3. Dodawanie zmian  

Dodanie pojedynczego pliku

git add Program.cs

Dodanie wszystkich zmodyfikowanych plików\

git add .

Przenosi zmiany do tzw. “staging area”, czyli przygotowuje je do zapisania w historii projektu.

4. Tworzenie commita

git commit -m "Added a new feature"

Zapisuje zmiany w historii repozytorium wraz z krótkim, opisowym komunikatem, który wyjaśnia, co zostało zaktualizowane.

5. Przeglądanie historii

git log

Wyświetla listę commitów z informacjami, takimi jak identyfikator commitu, autor, data i opis zmian.

Te komendy to podstawowe narzędzia, dzięki którym możesz sprawnie zarządzać kodem, kontrolować jego historię i organizować pracę nad projektem. Są to pierwsze kroki, aby poczuć się pewnie w środowisku Git.

Praktyczny Przykład: Tworzenie Projektu Kalkulatora w C# i Zarządzanie Nim za Pomocą Git

Aby lepiej zrozumieć, jak używać Git w praktyce, przyjrzyjmy się prostemu projektowi konsolowego kalkulatora w C#. Oto, jak krok po kroku zarządzać tym projektem przy użyciu Git.

Krok 1: Inicjalizacja Projektu

Najpierw utwórz folder na projekt, przejdź do niego i zainicjalizuj repozytorium Git. Następnie rozpocznij nowy projekt w C#.

mkdir Calculator
cd Calculator
git init
dotnet new console

Powyższe polecenia:

• Tworzą nowy katalog projektu (Calculator),
• Inicjalizują puste repozytorium Git w tym katalogu (git init),
• Generują szkielet konsolowej aplikacji C# (dotnet new console).

Krok 2: Pierwszy Commit

Teraz otwórz wygenerowany plik Program.cs w swoim ulubionym edytorze kodu i wprowadź następujące zmiany:

using System;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Prosty Kalkulator");
    }
}

Dodaj zmieniony plik do obszaru staging i zapisz zmiany jako pierwszy commit w historii repozytorium:

git add Program.cs
git commit -m "Calculator project initialization" 

Co Zrobiłeś do Tej Pory?

• git add Program.cs: Dodaje zmiany w pliku Program.cs do obszaru staging.
• git commit -m "Calculator project initialization": Tworzy pierwszy snapshot projektu z informacją o zmianach.

Zasada Dobrego Commitu

Zawsze używaj opisowych komunikatów przy commitach. W tym przypadku informujemy, że zainicjalizowaliśmy projekt kalkulatora.

Teraz Twój projekt jest gotowy do dalszej rozbudowy i śledzenia zmian w kodzie za pomocą Git! 🎉

Krok 3: Dodanie Funkcji Dodawania

W tym kroku rozszerzymy nasz kalkulator o podstawową funkcjonalność — dodawanie dwóch liczb.

Modyfikacja Kodów w Program.cs

Zmień zawartość pliku Program.cs, aby wyglądał następująco:

using System;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Prosty Kalkulator");
        Console.WriteLine($"10 + 5 = {Add(10, 5)}");
    }
    static int Add(int x, int y)
    {
        return x + y;
    }
}

• Co się zmieniło?
  • Dodaliśmy funkcję Add(int x, int y), która przyjmuje dwie liczby całkowite jako argumenty i zwraca ich sumę.
  • Wywołujemy tę funkcję w Main i wyświetlamy wynik na konsoli.

Commitowanie Zmian

Po zapisaniu pliku Program.cs dodaj zmiany do obszaru staging i stwórz commit:

git add Program.cs
git commit -m "Added addition functionality"

git add Program.cs: Dodaje zmodyfikowany plik do obszaru staging.
git commit -m "Added addition functionality": Zapisuje zmiany w historii repozytorium z opisem informującym o dodanej funkcji dodawania.

Krok 4: Tworzenie nowej gałęzi dla funkcji odejmowania

W tym kroku dodamy funkcję odejmowania do naszego kalkulatora, zarządzając zmianami w oddzielnej gałęzi.

Tworzenie Nowej Gałęzi i Przełączanie się na Nią

Najpierw stwórz nową gałąź dla funkcji odejmowania:

Standardowe Podejście:

git branch subtraction-feature
git checkout subtraction-feature

Krótsza Instrukcja (zalecane):
Jednocześnie tworzysz nową gałąź i przełączasz się na nią:

git checkout -b subtraction-feature

Modyfikacja Kodów w Program.cs

Dodaj funkcję Subtract do swojego projektu, modyfikując plik Program.cs:

using System;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Prosty Kalkulator");
        Console.WriteLine($"10 + 5 = {Add(10, 5)}");
        Console.WriteLine($"25 - 10 = {Subtract(25, 10)}");
    }
    …
    static int Subtract(int x, int y)
    {
        return x - y;
    }
}

Dodane Zmiany:

• Funkcja Subtract(int x, int y) przyjmuje dwie liczby całkowite i zwraca ich różnicę.
• W Main dodaliśmy wywołanie funkcji Subtract z odpowiednimi argumentami oraz wyświetlenie wyniku.

Commitowanie Zmian

Po zapisaniu zmian w pliku Program.cs, dodaj je do obszaru staging i stwórz commit:

git add Program.cs
git commit -m "Added subtraction functionality" 

• git add Program.cs: Dodaje zmodyfikowany plik do staging area.
• git commit -m "Added subtraction functionality": Zapisuje w historii repozytorium, co zostało dodane.

Korzyści z Pracy na Gałęziach

Dzięki temu podejściu możesz:

1. Niezależnie rozwijać nową funkcjonalność, nie wpływając na główną linię rozwoju (main).
2. W przyszłości wprowadzać kolejne zmiany i dopiero po przetestowaniu włączyć je do głównej gałęzi przy użyciu git merge.

Twój kalkulator posiada już dwie podstawowe operacje matematyczne, a historia zmian jest uporządkowana! 👌

Krok 5: Łączenie gałęzi

W tym kroku połączymy zmiany z gałęzi subtraction-feature z główną gałęzią master.

Krok 5.1: Przełączanie się na Główną Gałąź

Najpierw wracamy do głównej gałęzi (w domyślnych ustawieniach nazywa się master lub main, w zależności od konfiguracji repozytorium):

git checkout master

Łączenie Gałęzi

Aby włączyć zmiany wprowadzone na gałęzi subtraction-feature do głównej gałęzi, użyj komendy:

git merge subtraction-feature

Efekt:

• Wszystkie zmiany z gałęzi subtraction-feature zostaną scalone z aktualnym stanem gałęzi master.
• Jeśli nie ma konfliktów, zmiany zostaną automatycznie połączone.
• Historia commitów z gałęzi subtraction-feature zostanie zachowana w głównej gałęzi.

Sprawdzanie Statusu Po Scaleniu

Aby upewnić się, że wszystko przebiegło prawidłowo:

git status

Krok 6: Utworzenie pliku .gitignore

Plik .gitignore służy do wskazywania plików i katalogów, które powinny być ignorowane przez Git. Jest to szczególnie przydatne w projektach .NET, gdzie niektóre pliki (np. kompilowane binaria) nie są potrzebne w repozytorium.

Jak utworzyć plik .gitignore?

Utwórz plik .gitignore w głównym katalogu projektu. Możesz to zrobić za pomocą edytora tekstu lub komendą w terminalu:

echo > .gitignore

Następnie edytuj plik .gitignore, aby dodać odpowiednie wzorce ignorowanych plików.

Wzorce w .gitignore dla projektów .NET

W przypadku projektów .NET warto dodać poniższe wzorce:

# Ignorowanie plików binarnych / kompilacji
[Dd]ebug/
[Rr]elease/
[Bb]in/
[Oo]bj/
x64/

# Ignoruj pliki tymczasowe
*.log
*.tmp

# Ignoruj pliki użytkownika
*.user
*.suo
*.sln.docstates

I inne w miare potrzeb a może byc tego całkiem sporo.

Jeśli chcesz szybko wygenerować .gitignore dopasowany do swojego projektu, możesz skorzystać z serwisu gitignore.io (https://www.toptal.com/developers/gitignore), 
gdzie wystarczy wybrać platformę .NET lub język C#, aby otrzymać gotowy szablon pliku.

Dzięki plikowi .gitignore Twój projekt będzie lepiej zorganizowany, a repozytorium nie zostanie zaśmiecone zbędnymi plikami!

Dodanie .gitignore do repozytorium

Aby dodać .gitignore do repozytorium:

git add .gitignore
git commit -m "Added .gitignore file"

Krok 7: Utworzenie Repozytorium Zdalnego (na GitHubie)

Aby w pełni wykorzystać możliwości Git, możesz stworzyć zdalne repozytorium, które pozwoli Ci przechowywać projekt w chmurze, udostępniać go innym programistom i synchronizować zmiany między różnymi komputerami.

Jak utworzyć zdalne repozytorium na GitHubie?

1. Zaloguj się do GitHuba
   Przejdź na stronę GitHub i zaloguj się na swoje konto.
2. Stwórz nowe repozytorium

2. Wybierz opcję New repository.
3. Wypełnij pola:
   • Repository name: Podaj nazwę repozytorium, np. Calculator.
   • (Opcjonalnie) Dodaj opis repozytorium.
   • Zaznacz, czy repozytorium ma być publiczne czy prywatne.
4. Kliknij przycisk Create repository.
5. Połącz lokalne repozytorium z GitHubem
   W terminalu wykonaj następujące kroki:
6. Ustaw zdalny adres (zastąp your-username i KalkulatorGit swoimi danymi):

git remote add origin https://github.com/your-username/Calculator.git

Sprawdź, czy zdalne repozytorium zostało dodane:

git remote -v

Powinno wyświetlić coś podobnego:

origin  https://github.com/your-username/Calculator.git (fetch)
origin  https://github.com/your-username/Calculator.git (push)

Prześlij zmiany do zdalnego repozytorium

1. Upewnij się, że masz już jakieś commity w swoim lokalnym repozytorium (wcześniejsze kroki opisują, jak to zrobić).
2. Wypchnij zmiany do zdalnego repozytorium:

git branch -M master  # Ustaw gałąź główną jako "master"
git push -u origin master

Sprawdź repozytorium na GitHubie
Odśwież stronę repozytorium na GitHubie, aby zobaczyć przesłane pliki.

Po skonfigurowaniu zdalnego repozytorium Twoja praca stanie się bardziej bezpieczna, dostępna z każdego miejsca i gotowa do współpracy w zespole!

Krok 8: Dodawanie kolejnych commitów i synchronizacja z GitHubem

Gdy Twój projekt się rozwija, będziesz regularnie dodawać nowe funkcje, poprawki i zmiany. Poniżej znajdziesz opis procesu:

1. Wprowadź zmiany do kodu

Dokonaj potrzebnych modyfikacji w swoim projekcie.
Na przykład, dodajmy nową funkcję mnożenia w Program.cs:

using System;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Prosty Kalkulator");
        Console.WriteLine($"5 * 5 = {Multiply(5, 5)}");
    }

    static int Multiply(int x, int y)
    {
        return x * y;
    }
}

2. Sprawdź stan repozytorium

Aby zobaczyć, jakie pliki zostały zmienione lub dodane, użyj komendy:

git status

Przykładowy wynik:

On branch master
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
        modified: Program.cs

3. Dodaj zmiany do staging area

Dodaj zmienione pliki do obszaru staging:

git add Program.cs

Jeśli chcesz dodać wszystkie zmienione pliki, użyj:

git add .

4. Zapisz commit z opisem zmian

Zapisz zmiany w lokalnym repozytorium, tworząc commit. Dodaj opis, co zmieniłeś:

git commit -m "Added multiplication functionality"

5. Synchronizacja z GitHubem

1. Pobierz ewentualne zmiany ze zdalnego repozytorium
   Przed przesłaniem swoich zmian upewnij się, że masz najnowszą wersję projektu:

git pull origin master

• Wypchnij zmiany do zdalnego repozytorium
  Po udanym pobraniu możesz przesłać swoje zmiany na GitHuba:

git push origin master

6. Weryfikacja na GitHubie

Odśwież stronę swojego zdalnego repozytorium na GitHubie, aby zobaczyć zaktualizowane pliki i historię commitów.

Przykład cyklu pracy z Git i GitHub

1. Wprowadzasz zmiany: Kodujesz nowe funkcje, poprawiasz błędy.
2. Dodajesz zmiany: Używasz git add, aby przygotować pliki do commitu.
3. Commitujesz zmiany: Zapisujesz zmiany z opisem (git commit -m).
4. Synchronizujesz: Pobierasz (git pull) i wysyłasz (git push) zmiany na GitHuba.

Dobre praktyki przy synchronizacji

1. Regularnie commituj małe zmiany
   Lepsze są częste i mniejsze commity niż ogromne, które trudno opisać.
2. Unikaj konfliktów
   • Przed każdym git push, wykonaj git pull, aby upewnić się, że masz najnowsze zmiany.
   • Konflikty możesz rozwiązać w lokalnym repozytorium, jeśli pojawią się rozbieżności w kodzie.
3. Pracuj na gałęziach
   • Dla każdej większej funkcji twórz osobne gałęzie i scalaj je dopiero po przetestowaniu.

Synchronizacja Twojej pracy z GitHubem to kluczowy element dobrego zarządzania projektami, szczególnie w zespołach!

Krok 9: Dodanie funkcji dzielenia i korzystanie z Pull Request

W tym kroku pokażemy, jak dodać funkcję dzielenia w sposób umożliwiający lepszą współpracę i kontrolę zmian poprzez wykorzystanie Pull Request (PR).

1. Stwórz nową gałąź dla funkcji dzielenia

Aby uniknąć problemów z główną gałęzią (master), rozpocznij prace nad funkcją dzielenia w osobnej gałęzi:

git checkout -b division-feature

2. Wprowadź zmiany w kodzie

Dodaj funkcję dzielenia do pliku Program.cs:

using System;
class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Prosty Kalkulator");
        Console.WriteLine($"10 / 2 = {Divide(10, 2)}");
    }

    static int Divide(int x, int y)
    {
        if (y == 0)
        {
            throw new DivideByZeroException("Nie można dzielić przez zero.");
        }
        return x / y;
    }
}

3. Sprawdź zmiany

Upewnij się, że zmiany zostały poprawnie wprowadzone, używając:

git status

4. Dodaj i commituj zmiany

Przygotuj zmiany do commitu i zapisz je:

git add Program.cs
git commit -m "Added division functionality"

5. Wypchnij zmiany do zdalnego repozytorium

Prześlij nową gałąź na GitHuba:

git push origin division-feature

6. Stwórz Pull Request na GitHubie

1. Otwórz swoje repozytorium na GitHubie.
2. Przejdź do zakładki Pull Requests.
3. Kliknij przycisk New Pull Request.
4. Wybierz jako bazową gałąź master oraz gałąź, którą chcesz połączyć, czyli funkcja-dzielenia.
5. Sprawdź zmiany, dodaj opis i utwórz PR.

Przykładowy opis PR:

Dodano funkcję dzielenia do kalkulatora.
Umożliwia dzielenie dwóch liczb oraz obsługuje przypadek dzielenia przez zero poprzez zgłoszenie wyjątku.

7. Dokonaj przeglądu Pull Request

1. Jeśli pracujesz w zespole, pozostali członkowie mogą teraz przejrzeć kod i zasugerować zmiany lub zatwierdzić PR.
2. Jako autor PR możesz poprawić swój kod w oparciu o sugestie, dodając kolejne commity do tej samej gałęzi.

8. Scal Pull Request

Gdy PR zostanie zaakceptowany, scal go z główną gałęzią (main):

1. Na stronie PR kliknij Merge Pull Request.
2. Usuń gałąź division-feature, jeśli nie będzie już potrzebna.

9. Zaktualizuj lokalne repozytorium

Aby zsynchronizować zmiany, pobierz najnowszy kod z main:

git checkout master
git pull origin master

Podsumowanie Korzyści z Pull Request

• Lepsza kontrola zmian: Każdy PR umożliwia dokładne prześledzenie i omówienie wprowadzanych modyfikacji.
• Łatwa współpraca: Pozwala na wspólną pracę w zespole, nawet nad drobnymi funkcjami.
• Historia zmian: PR pozostaje w historii repozytorium, co ułatwia śledzenie, dlaczego zmiany zostały wprowadzone.

Korzystanie z Pull Request sprawia, że Twój projekt jest bardziej przejrzysty i zorganizowany!

Krok 10: Usuwanie branchy

0. Aby sprawdzić lokalne branche w Gicie, możesz użyć następującej komendy:

git branch

Wynik:

Ta komenda wyświetli listę wszystkich lokalnych gałęzi w repozytorium. Gałąź, na której obecnie się znajdujesz, będzie oznaczona gwiazdką (*).

Opcje dodatkowe:

• Aby zobaczyć również zdalne gałęzie (razem z lokalnymi):

git branch -a

• Jeśli chcesz sprawdzić szczegółowe informacje, takie jak hash ostatniego commita i jego opis, użyj:

git branch -v

• Aby wyświetlić gałęzie lokalne powiązane ze zdalnymi (tracking branches):

git branch -vv

1. Usunięcie lokalnego brancha:

Aby usunąć branch lokalny, użyj komendy:

git branch -d nazwa_brancha

Przykład:

git branch -d feature-branch

Warunki:

• Branch nie zostanie usunięty, jeśli nie został zmergowany z główną gałęzią lub innym branczem. W takim przypadku Git wyświetli ostrzeżenie.

Jeśli chcesz wymusić usunięcie brancha (nawet niezmerge’owanego), użyj:

git branch -D nazwa_brancha

Przykład:

git branch -D feature-branch

2. Usunięcie zdalnego brancha:

Aby usunąć branch na zdalnym repozytorium, użyj:

git push origin --delete nazwa_brancha

Przykład:

git push origin --delete feature-branch

Wskazówki:

• Unikaj usuwania aktualnej (aktywnej) gałęzi. Zawsze upewnij się, że przebywasz na innej gałęzi, np. main lub develop.
• Aby upewnić się, że branch nie jest już potrzebny, sprawdź, czy został zmergowany:

git branch --merged

Dobre praktyki dotyczące zdalnych repozytoriów

1. Regularny push i pull
   Regularnie przesyłaj zmiany do zdalnego repozytorium (git push) oraz pobieraj zmiany wprowadzone przez innych (git pull), aby utrzymać synchronizację.
2. Używaj .gitignore
   Zanim prześlesz pliki do zdalnego repozytorium, upewnij się, że .gitignore chroni Twoje repozytorium przed przesłaniem zbędnych plików.
3. Dodaj plik README.md
   Stwórz czytelny plik README.md zawierający opis projektu i instrukcje dla użytkowników oraz współpracowników.
4. Korzystaj z pull requestów
   W zespołach korzystaj z pull requestów, aby kontrolować wprowadzanie zmian i współpracować bardziej efektywnie.

Dobre praktyki w używaniu Git

    1. Częste commity
– rób małe, logiczne commity zamiast dużych, zawierających wiele zmian.
    2. Opisowe komunikaty commitów
– pisz jasne i zwięzłe opisy tego, co zostało zmienione.
    3. Używaj gałęzi
– twórz osobne gałęzie dla nowych funkcji lub eksperymentów.
    4. Regularnie synchronizuj
– jeśli pracujesz w zespole, często pushuj i pulluj zmiany.
    5. Używaj .gitignore
– ignoruj pliki, które nie powinny być śledzone (np. pliki konfiguracyjne, binaria, itp.).

Git to jedno z najważniejszych narzędzi w arsenale współczesnego programisty, które znacząco ułatwia zarządzanie projektami oraz współpracę w zespołach developerskich. Jego uniwersalność, niezawodność i popularność sprawiają, że stał się standardem w branży IT.

Dlaczego warto korzystać z Git?

Git umożliwia śledzenie historii zmian w projekcie, co jest nieocenione zarówno w pracy indywidualnej, jak i zespołowej. Dzięki niemu można:

• Przechowywać historię wersji kodu — każda zmiana wprowadzona do projektu jest zapisana, co pozwala na łatwe wycofanie się do poprzednich wersji.
• Pracować nad kodem równocześnie z innymi — gałęzie (branches) pozwalają na jednoczesne rozwijanie nowych funkcjonalności bez ryzyka konfliktów.
• Unikać utraty pracy — kopie zapasowe kodu przechowywane w repozytoriach zdalnych (np. GitHub, GitLab) zabezpieczają przed niespodziewaną utratą danych.

Git w ekosystemie .NET

W pracy z technologiami .NET znajomość Git jest wręcz obowiązkowa. Większość projektów komercyjnych wykorzystuje repozytoria Git jako centralne miejsce zarządzania kodem. Dzięki integracji z narzędziami, takimi jak Visual Studio czy Rider, korzystanie z Git w projektach .NET jest niezwykle intuicyjne.

Kluczowe komendy Git dla programistów .NET

Oto kilka podstawowych komend Git, które każdy programista powinien znać:

• git init — inicjalizacja nowego repozytorium Git.
• git add <plik> — dodanie plików do obszaru staging.
• git commit -m "opis zmian" — zapisanie zmian w repozytorium.
• git push — wysłanie lokalnych zmian do zdalnego repozytorium.
• git pull — pobranie zmian ze zdalnego repozytorium.
• git branch — zarządzanie gałęziami w projekcie.

Podsumowanie

Opanowanie podstaw Git to krok, którego nie można pominąć w rozwoju kariery jako programista, zwłaszcza w środowisku .NET. Dzięki Git możesz pracować efektywniej, unikać błędów i lepiej współpracować z zespołem. Niezależnie od tego, czy tworzysz małe aplikacje czy rozbudowane systemy, Git będzie Twoim niezastąpionym wsparciem.