fr/basic.txt

   1 == Astuces de base  ==
   2
   3 Plutôt que de plonger dans l'océan des commandes Git, utilisez ces exemples
   4 élémentaires pour mouiller vos pieds. Malgrés leur simplicité, chacun d'eux est
   5 utile.  En effet, lors de mon premier mois d'utilisation de Git, je ne me suis
   6 jamais aventuré au delà de ce qui est exposé dans ce chapitre.
   7
   8 === Enregistrer l'état courant ===
   9
  10 Vous êtes sur le point d'effecture une opération drastique ? Avant de le faire,
  11 réalisez une capture de tous les fichiers dans le dossier courant :
  12
  13  $ git init $ git add .  $ git commit -m "Ma première sauvegarde"
  14
  15 Si jamais votre opération tourne mal, vous pouvez retrouver votre version
  16 initiale, immaculée :
  17
  18  $ git reset --hard
  19
  20 Pour enregistrer à nouveau l'état :
  21
  22  $ git commit -a -m "Une autre sauvegarde"
  23
  24 === Ajouter, supprimer, renommer ===
  25
  26 Les commandes ci-dessus ne font que garder traces des fichiers qui étaient
  27 present lorsque vous avez executé *git add* pour la première fois. Si vous
  28 ajoutez de nouveaux fichiers ou sous dossiers, il faut le signaler à Git :
  29
  30  $ git add readme.txt Documentation
  31
  32 De même, si vous voulez que Git oublie certains fichiers :
  33
  34  $ git rm kludge.h obsolete.c $ git rm -r incriminating/evidence/
  35
  36 Git supprime les fichiers pour vous si vous ne l'avez pas encore fait.
  37
  38 Renommer un fichier revient à supprimer l'ancien nom et ajouter le nouveau. Il
  39 y a également le raccourci *git mv* qui à la même syntaxe que la commande mv.
  40 Par exemple :
  41
  42  $ git mv bug.c feature.c
  43
  44 === Annuler/Reprendre avancé ===
  45
  46 Parfois vous voulez seulement revenir en arrière et oublier les modification
  47 depuis un certain moment parcequ'elle sont toutes fausses. Dans ce cas :
  48
  49  $ git log
  50
  51 vous montre un list des commits récents, accompagné de leur clé de hashage
  52 SHA1 :
  53
  54 ---------------------------------- commit
  55 766f9881690d240ba334153047649b8b8f11c664 Author: Bob <bob@example.com> Date:
  56 Tue Mar 14 01:59:26 2000 -0800
  57
  58     Remplacement de prinf() par write()
  59
  60 commit 82f5ea346a2e651544956a8653c0f58dc151275c Author: Alice
  61 <alice@example.com> Date:   Thu Jan 1 00:00:00 1970 +0000
  62
  63     Commit initial ----------------------------------
  64
  65 Les premiers charactères fu hash sont suffisant pour spécifier le commit ;
  66 éventuellement, copiez et collez le hash en entier. Saisissez :
  67
  68  $ git reset --hard 766f
  69
  70 pour restaurer l'état correspondant au commit donné et supprimer de manière
  71 permanente tout les commit plus récents de l'enregistrement.
  72
  73 D'autres fois vous voulez faire un saut rapide dans un état précédent. Dans ce
  74 cas, saisissez :
  75
  76  $ git checkout 82f5
  77
  78 Ceci vous ramène en arrière dans le temps, tout en conservant les commit
  79 récents. Toutefois, comme pour le voyage dans le temps de la science fiction,
  80 si vous modifiez et faite un commit, vous serez dans une réalité alternative,
  81 parceque vos actions sont différentes de ce qu'elle étaient la première fois.
  82
  83 Cette réalité alternative est appelé une 'branche' ('branch'), et <<branch,nous
  84 en dirons plus après>>. Pour le moment rapellez vous simplement que :
  85
  86  $ git checkout master
  87
  88 vous ramènera dans le présent. De plus, au lieu de vous plaindre bâtement,
  89 réalisé toujours un commit ou reset de vos modification avant de faire un
  90 checkout.
  91
  92 Pour reprendre l'analogie du jeux vidéo :
  93
  94 - *`git reset --hard`*: recharger un vieil enregistrement et supprimer toutes
  95   les parties sauvegardées plus récement que celle qui vient d'être chargée.
  96
  97 - *`git checkout`*: recharger une ancienne partie, mais si vous jouez l'état de
  98   la partie va différé des enregistrement suivant que vous aviez réalisé la
  99   première fois. Chaque nouvelle sauvegarde sera sur une branche séparée
 100   représentant la réalité alternative dans laquelle vous êtes entrée.
 101   <<branch,on s'en occupe plus loin>>.
 102
 103
 104 Vous pouvez choisir de ne restaurer que certains fichiers et sous dossiers en
 105 les nommant à la suite de la commande :
 106
 107  $ git checkout 82f5 un.fichier un-autre.fichier
 108
 109 Faites attention car cette forme de *checkout* peut écraser vos fichier sans
 110 crier gare. Pour éviter les accidents, faite un commit avant toute commande
 111 checkout, surtout quand vous débutez avec Git. En général, quand vous n'êtes
 112 pas sur de vous sur une opération, et pas seulement pour une commande Git, fait
 113 d'abord un *git commit -a*.
 114
 115 Vous n'aimez pas copier et coller les clés de hashages ? Alors utilisez :
 116
 117  $ git checkout :/"Mon premier b"
 118
 119 pour arriver sur le commit qui commence avec ce message.  Vous pouvez aussi
 120 demander la cinquième sauvegarde en arrière :
 121
 122  $ git checkout master~5
 123
 124 === Reprise (revert) ===
 125
 126 Dans une cours de justice, certains évènements peuvent être effacé du procès
 127 verbal. De même vous pouvez sélectionner des commits spécifiques à défaire :
 128
 129  $ git commit -a $ git revert 1b6d
 130
 131 défera le dernier commit ayant cette clé de hashage. La reprise est enregistrée
 132 comme un nouveau commit, ce que vous pourrez constater en lançant un *git log*.
 133
 134 === Génération du journal des modifications (changelog) ===
 135
 136 Certains projets demandent un
 137 http://en.wikipedia.org/wiki/Changelog[changelog].  Générez le en tapant :
 138
 139  $ git log > ChangeLog
 140
 141 === Télécharger des fichiers ===
 142
 143 Fait une copie d'un projet gérer par Git en saisissant :
 144
 145  $ git clone git://serveur/chemin/vers/les/fichiers
 146
 147 Par exemple, pour avoir les fichiers qui ont été utilisés pour créer ce site :
 148
 149  $ git clone git://git.or.cz/gitmagic.git
 150
 151 Nous aurons beaucoup à dire sur la command *clone* d'ici peu.
 152
 153 === Le dernier cri ===
 154
 155 Si vous avez déjà téléchargée une copie d'un projet en utilisant *git clone*,
 156 vous pouvez mettre à jour le code à la dernière version avec :
 157
 158  $ git pull
 159
 160 === Publication instantanée ===
 161
 162 Imaginez que vous avec écrit un script que vous voudriez partager avec
 163 d'autres. Vous pourriez leur dire de le télécharger de votre ordinateur, mais
 164 si ils le font au moment ou vous êtes en train d'améliorer le script ou d'y
 165 effectuer des modifications expérimentales, ils peuvent se retrouver dans la
 166 panade. Bien sur, c'est pour cela que l'on a créé la publication de versions
 167 successives. Les développeurs peuvent travailler sur un projet fréquement, mais
 168 ils ne rendent le code disponible quand il le trouvent présentable.
 169
 170 Pour faire ça avec Git, dans le dossier qui contient votre script :
 171
 172  $ git init $ git add .  $ git commit -m "Première publication"
 173
 174 Ensuite vous pouvez dire à vos utilisateur de lancer :
 175
 176  $ git clone votre.ordinateur:/chemin/vers/le/script
 177
 178 pour télécharger votre script. En considérant qu'ils ont un accès ssh. Sinon,
 179 lancez *git daemon* et dites plutôt à vos utilisateur de lancer :
 180
 181  $ git clone git://votre.ordinateur/chemin/vers/le/script
 182
 183 À partir de maintenant, chaque fois que votre script est prêt à être publié,
 184 exécutez :
 185
 186  $ git commit -a -m "Nouvelle version"
 187
 188 et vos utilisateurs peuvent mettre à jour leur version en allant dans le
 189 dossier contenant votre script et en saisissant :
 190
 191  $ git pull
 192
 193 Vos utilisateurs ne se retrouverons jamais avec une version de votre script que
 194 vous ne vouliez pas leur montrer.
 195
 196 === Qu'ai je fais ? ===
 197
 198 Retrouvez les modification faites depuis le dernier commit avec :
 199
 200  $ git diff
 201
 202 Ou depuis hier :
 203
 204  $ git diff "@{yesterday}"
 205
 206 Ou entre un version spécifique et la deux versions en arrière :
 207
 208  $ git diff 1b6d "master~2"
 209
 210 Dans chacun de ces cas, la sortie est un *patch* (rustine) qui peut être
 211 appliqué en utilisant *git apply*.  Vous pouvez aussi essayer :
 212
 213  $ git whatchanged --since="2 weeks ago"
 214
 215 Souvent je parcours plutôt l'historique avec
 216 http://sourceforge.net/projects/qgit[qgit], pour sa pimpante interface
 217 photogénique, ou http://jonas.nitro.dk/tig/[tig], une interface en mode texte
 218 qui fonctionne même sur les connexions lentes. Autrement, installez un serveur
 219 web, lancez *git instaweb* et dégainez n'importe quel navigateur internet.
 220
 221
 222 === Exercice ===
 223
 224 Soit A, B, C, D quatre commits successifs où B est identique à A à l'exception
 225 de quelques fichiers qui ont été supprimés. Nous voudrions remettre les
 226 fichiers en D. Comment faire ?
 227
 228 Il y a au moins trois solutions. En considérant que nous sommes à D :
 229
 230   1. La différence entre A et B sont les fichiers supprimés. Nous pouvons créer
 231   un patch représentant cette différence et l'appliquer :
 232
 233    $ git diff B A | git apply
 234
 235   2. Vu que nous avions enregistré les fichiers en A, nous pouvons les
 236   reprendres :
 237
 238    $ git checkout A foo.c bar.h
 239
 240   3. Nous pouvons aussi voir le chemin de A à B comme une modification à
 241   défaire :
 242
 243    $ git revert B
 244
 245 Quel est le meilleur choix ? Celui que vous préférez. C'est facile d'obtenir ce
 246 que vous voulez avec Git, et souvent il y a plein de façon de l'avoir.