-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathindex.html
173 lines (168 loc) · 13.5 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>Summary</title>
<link rel="stylesheet" href="style.css" />
</head>
<body>
<div class="container">
<h1>Summary</h1>
<img src="https://images.ctfassets.net/lzny33ho1g45/72LQARTljGZuRJITF6GGUW/df456762851b5b12a1a135c923729703/app-tips-github-00-hero.png" />
<div class="summary">
<h2> 1) Introduction</h2>
<p>
Git est un logiciel de versioning créé en 2005 par Linus Torvalds, le
créateur de Linux. Il permet de conserver un historique des
modifications effectuées sur un projet, facilitant ainsi
l'identification des changements et le retour à des versions
antérieures en cas de besoin. Git est le leader incontesté parmi les
logiciels de gestion de versions et est indispensable pour tout
développeur. GitHub, quant à lui, est une plateforme de développement
collaboratif basée sur Git, permettant aux développeurs de travailler
ensemble sur des projets, de partager du code source et de gérer les
versions de leurs logiciels
</p>
<h2> 2) A quoi sert concrètement un système de gestion de version ?</h2>
<p>
Imaginez que vous ayez un site web nécessitant des modifications et
des tests fréquents. Si vous êtes seul, effectuer des sauvegardes et
restaurer le site en cas de problème est gérable. Cependant, si vous
êtes dix développeurs travaillant sur le même site avec des
fonctionnalités liées, il devient complexe de coordonner le travail,
de prévenir les conflits et de disposer de versions à jour du site.
Une solution logique serait d'utiliser Git, un logiciel de gestion de
version, pour permettre à chaque développeur d'accéder à l'historique
des modifications, de copier le contenu sur sa machine locale et de
synchroniser les différences avec le serveur. Git facilite la
coordination et la collaboration en préservant l'historique des
changements sur les fichiers et en permettant à différentes versions
de coexister.
</p>
<h2> 3) Les deux modèles des logiciels de gestion de version :</h2>
<p>
Les logiciels de gestion de version sont basés sur deux modèles : le
modèle centralisé et le modèle décentralisé. Le modèle centralisé
centralise le code source sur un serveur distant et les utilisateurs
doivent se connecter à ce serveur pour travailler. Dans le modèle
décentralisé, le code source est hébergé sur un serveur distant mais
chaque utilisateur doit télécharger et héberger l'intégralité du code
source sur sa propre machine. Le modèle décentralisé est avantageux
car il permet une simplicité et une flexibilité du travail, ainsi
qu'une sécurité accrue grâce aux copies de projets des utilisateurs.
Git est l'un des logiciels de gestion de version les plus populaires
utilisant le modèle décentralisé.
</p>
<h2> 4) Qu’est-ce que GitHub ?</h2>
<p>
Git est un logiciel de gestion de version qui permet d'enregistrer les
modifications effectuées sur un projet et de retourner à une version
précédente. GitHub est un service en ligne qui héberge des dépôts Git,
et est le plus grand hébergeur de dépôts Git du monde. GitHub permet à
n'importe qui de télécharger le code de dépôts publics et de
contribuer à leur développement en proposant de nouvelles
fonctionnalités. Git est donc le logiciel de gestion de version,
tandis que GitHub est un service en ligne d'hébergement de dépôts Git
qui fait office de serveur central pour ces dépôts
</p>
<h2> 5) Utiliser Git : ligne de commande, console et interface graphique</h2>
<p>
Dans ce cours, nous utilisons la console en ligne de commande plutôt
qu'une interface graphique pour installer et utiliser Git. Ce choix
est motivé par plusieurs raisons : La ligne de commande donne accès à
toutes les commandes Git. L'utilisation de la ligne de commande permet
une uniformité dans le suivi du cours pour tous les participants.
Savoir utiliser la version en ligne de commande facilite l'utilisation
de toute autre interface graphique. Sur Windows, pour ouvrir la ligne
de commande, vous pouvez utiliser le raccourci + cmd ou rechercher
"cmd" dans la barre de recherche.
</p>
<h2> 6) Installation de Git</h2>
<p>
La façon la plus simple d'installer Git est de télécharger la dernière
version sur le site officiel http://git-scm.com/downloads, puis de
suivre les instructions à l'écran en laissant les valeurs par défaut.
</p>
<h2> 7) Paramétrage de Git</h2>
<p>
Une fois Git installé, nous devons paramétrer le logiciel en
fournissant certaines données, telles que notre nom d'utilisateur et
notre adresse e-mail, afin de ne pas avoir à les saisir à nouveau
ultérieurement. Pour ce faire, nous utilisons la commande Git config,
qui permet de visualiser et de modifier les variables de configuration
contrôlant l'apparence et le comportement de Git. Nous utilisons
l'option --global pour indiquer que ces informations doivent être
utilisées de manière globale pour tous les projets Git. Les commandes
suivantes sont utilisées : git config --global user.name "Bouchekir
Redouane" et git config --global user.email
[email protected] (remplacez les valeurs par votre propre
nom et adresse e-mail). Vous pouvez vérifier si vos informations ont
été enregistrées en utilisant les commandes git config user.name et
git config user.email, qui devraient afficher les informations que
vous avez fournies.
</p>
<h2> 8) Démarrer un dépôt Git</h2>
<p>
Un dépôt Git est la copie complète et l'importation de tous les
fichiers d'un projet dans Git. Il existe deux méthodes pour créer un
dépôt Git : l'importation d'un répertoire existant ou le clonage d'un
dépôt Git déjà existant. Dans la suite de ce cours, nous explorerons
ces méthodes. Avant cela, il est important de comprendre la façon dont
Git gère les informations et son fonctionnement général.
</p>
<h2>9) La gestion des informations selon Git :</h2>
<p>
Git adopte une approche différente des autres systèmes de gestion de version en considérant les données comme des instantanés ou "snapshots". Chaque fois qu'un état de projet est enregistré dans Git, il crée un instantané du contenu de l'espace de travail et enregistre une référence à cet instantané. Les instantanés sont stockés localement dans une base de données sur notre machine. Cette approche permet d'effectuer la plupart des opérations de Git localement, sans nécessiter de connexion à un serveur central distant, ce qui les rend rapides et agréables à utiliser
</p>
<h2>10) Les états des fichiers</h2>
<p>
Dans Git, un fichier peut être soit "suivi" soit "non suivi". Un fichier suivi appartient au dernier instantané enregistré, tandis qu'un fichier non suivi ne fait pas partie de cet instantané. Lorsqu'on initialise un dépôt Git en important un répertoire existant, tous les fichiers sont initialement non suivis et doivent être indexés et validés. En revanche, lorsqu'on clone un dépôt Git existant, tous les fichiers sont déjà suivis par défaut. Un fichier suivi peut être dans l'un des trois états suivants : modifié, indexé ou validé. Lors du démarrage d'un dépôt local, tous les fichiers sont validés, tandis que lors du clonage, les fichiers sont automatiquement validés car ils sont enregistrés dans la base de données. Lorsqu'on travaille sur un projet, les fichiers modifiés sont considérés comme "modifiés" jusqu'à leur indexation. L'indexation indique à Git que le fichier doit être inclus dans le prochain instantané. Enfin, lorsque l'on demande à Git de prendre un instantané, les fichiers indexés et non modifiés sont validés, et le processus peut recommencer.
</p>
<h2>11) Les zones de travail</h2>
<p>
Git utilise trois zones de travail pour gérer les fichiers : le répertoire de travail, la zone d'index et le répertoire Git. Le répertoire de travail est une version extraite du projet où l'on peut travailler et modifier les fichiers. La zone d'index est un fichier qui stocke les informations sur les fichiers qui feront partie du prochain instantané ou commit. Le répertoire Git est l'endroit où sont stockées les méta-données et la base de données des objets du projet.
Le processus de travail consiste à effectuer des modifications dans le répertoire de travail. Les fichiers modifiés peuvent ensuite être indexés. Tant qu'un fichier n'est pas indexé, il est considéré comme modifié ou non suivi s'il est nouveau. Lorsqu'un fichier est indexé, son état devient indexé. Enfin, les fichiers indexés sont validés (committés) pour les ajouter au répertoire Git.
</p>
<h2>
12) Créer un dépôt Git à partir d’un répertoire existant
</h2>
<p>
Lorsque nous commençons avec Git, nous pouvons importer un projet existant en utilisant la commande "git init" pour créer un dépôt Git vide. Ensuite, nous pouvons utiliser la commande "git status" pour vérifier l'état des fichiers du projet. Les fichiers non suivis sont affichés comme "untracked".
Pour indexer des fichiers, nous utilisons la commande "git add". Nous pouvons spécifier des noms de fichiers, des répertoires ou utiliser des "fileglobs" pour ajouter plusieurs fichiers correspondant à un schéma. Une fois les fichiers indexés, la commande "git status" montre les fichiers ajoutés à l'index.
Pour valider les fichiers et les ajouter en base, nous utilisons la commande "git commit". Un message de commit est requis pour documenter les modifications. Après avoir entré le message, nous quittons l'éditeur et les fichiers sont validés.
En vérifiant à nouveau l'état avec "git status", Git nous indique qu'il n'y a plus de fichiers non suivis et que les modifications ont été enregistrées
</p>
<h2>
13) Cloner un dépôt Git
</h2>
<p>
La deuxième façon de démarrer un dépôt Git est de cloner un dépôt Git existant en utilisant la commande "git clone". Pour cela, nous devons créer un dépôt sur GitHub. Ensuite, nous pouvons utiliser les commandes "git branch -M main", "git remote add origin [URL du dépôt]" et "git push -u origin main" pour ajouter les fichiers locaux au dépôt distant. Cela permet de transférer nos fichiers vers le dépôt GitHub que nous avons créé.
</p>
<h2>
14) Ajouter ou modifier des fichiers dans un projet etactualiser notre dépôt Git
</h2>
<p>
Lorsque nous travaillons sur notre projet, nous devons ajouter, modifier ou supprimer des fichiers, et nous devons informer Git de ces changements pour qu'il puisse enregistrer l'historique des versions. Pour enregistrer une modification ou un ajout de fichier dans le dépôt Git, nous utilisons les commandes "git add" et "git commit". Il est important de noter que le commit d'un fichier est basé sur son état au moment de la commande "git add". Ainsi, si vous effectuez des modifications après avoir utilisé "git add" et avant "git commit", seules les modifications au moment de "git add" seront enregistrées. Pour simplifier le processus, vous pouvez utiliser la commande "git commit -a" pour ajouter et valider automatiquement les fichiers modifiés qui sont déjà suivis, sans avoir besoin de taper "git add"
</p>
<h2>
15) Consulter l’historique des modifications Git
</h2>
<p>
La commande "git log" permet de consulter l'historique des modifications Git en affichant la liste des commits du plus récent au plus ancien, avec des informations telles que la somme de contrôle SHA-1, le nom de l'auteur, la date et le message du commit.
</p>
<h2>
16) Annuler des modifications apportées à un fichier
</h2>
<p>
La possibilité de revenir à un état antérieur enregistré d'un projet est l'un des principaux avantages d'un logiciel de gestion de version. Après un commit, si des modifications ne donnent pas les résultats escomptés, on peut utiliser la commande "git checkout -- nom-du-fichier" ou la nouvelle commande "git restore" pour revenir à l'état du fichier du dernier instantané enregistré
</p>
<h2>
17) Qu’est ce qu’une branche ?
</h2>
<p>
Créer une branche dans Git permet de développer et tester de nouvelles fonctionnalités sans affecter le projet principal. Contrairement à d'autres systèmes de contrôle de version, Git utilise des pointeurs vers des commits pour représenter les branches, ce qui facilite la création et la fusion des branches. La branche par défaut s'appelle "master" et se déplace automatiquement à chaque nouveau commit. Une branche est simplement un pointeur vers un commit spécifique, et un commit est un objet qui contient un pointeur vers l'instantané du contenu indexé ainsi que des pointeurs vers les commits précédents. En résumé, créer une nouvelle branche dans Git consiste à créer un nouveau pointeur plutôt que de copier l'intégralité du répertoire de travail.
</p>
</div>
</div>
</body>
</html>