Git

ma réponse inclut github comme beaucoup de gens ont demandé à ce sujet aussi.

Dépôts Locaux

Git (local) a un répertoire (.git) dans lequel vous propagez vos fichiers et c'est votre "dépôt local". C'est différent des systèmes comme svn où vous ajoutez et commutez immédiatement dans le dépôt distant.

git stocke chaque version d'un fichier qui change en sauvegardant le fichier entier. Il est également différent de svn à cet égard car vous pouvez aller à n'importe quelle version individuelle sans la "recréer" par des modifications delta.

Git ne "verrouille" pas du tout les fichiers et évite ainsi la fonctionnalité de "verrouillage exclusif" pour une édition (les anciens systèmes comme pvcs viennent à l'esprit), de sorte que tous les fichiers peuvent toujours être édités, même lorsqu'ils sont hors ligne. Il fait en fait un travail incroyable de la fusion des changements de dossier (dans le même fichier!) ensemble lors de pulls ou de fetches/pushs vers un dépôt distant tel que github. La seule fois où vous avez besoin de faire des modifications manuelles (éditant en fait un fichier) est si deux modifications impliquent la même ligne de code.

Branches

vous permettent de conserver le code principal (la branche 'master'), de faire une copie (une nouvelle branche) et de travailler ensuite au sein de cette nouvelle branche. Si le travail prend du temps ou le maître reçoit beaucoup de les mises à jour depuis que la branche a été faite, alors la fusion ou le rebasement (souvent préféré pour une meilleure histoire et plus facile à résoudre les conflits) contre la branche principale devrait être fait. Lorsque vous avez terminé, vous fusionnez les changements effectués dans la branche vers le dépôt principal. De nombreuses organisations utilisent des branches pour chaque travail, qu'il s'agisse d'une fonctionnalité, d'un bug ou d'un élément de travail. D'autres organisations n'utilisent les branches que pour les changements majeurs tels que les mises à niveau de versions. Fourche: avec une branche, vous contrôlez et gérez le alors qu'avec une fourchette, quelqu'un d'autre contrôle l'acceptation du code.

De façon générale, il y a deux approches principales pour faire des directions générales. La première est de garder la plupart des changements sur la branche principale, en n'utilisant les branches que pour les choses plus grandes et plus longues comme les changements de version où vous voulez avoir deux branches disponibles pour des besoins différents. La seconde consiste à faire une branche pour chaque requête de fonctionnalité, Correction de bug ou corvée et ensuite décider manuellement quand pour fusionner ces branches dans la branche principale. Bien que cela semble fastidieux, c'est une approche commune et c'est celle que j'utilise actuellement et recommande parce que cela garde la branche principale propre et c'est le maître que nous promouvons à la production, donc nous voulons seulement du code complet et testé, via le rebasing et la fusion de branches.

la méthode standard pour amener une branche "in "à master est de faire un merge . Les Branches peuvent également être rebase d à 'nettoyer 'l'histoire. Il n'affecte pas l'état actuel et est fait pour donner une histoire "propre". Fondamentalement, l'idée est que vous ramifié à partir d'un certain point (généralement à partir de maître). Depuis que vous avez ramifié "maître" lui-même a progressé. Donc ce serait plus propre si tout ce que vous avez changé dans une branche est joué contre le maître le plus récent avec tous ses changements. Ainsi, le processus est: enregistrer les modifications; obtenir le "nouveau" maître, puis réappliquer les modifications de nouveau contre. Soyez conscient que rebase, tout comme la fusion, peut entraîner des conflits que vous devez résoudre manuellement (éditer).

Un 'guide' note: Seulement "rebase" si la branche est local et que vous n'avez pas poussé à distance encore! c'est principalement parce que le rebasement peut modifier l'histoire que d'autres personnes voient qui peut inclure leurs propres commits.

Suivi des branches

ce sont les branches qui sont nommées origine/branch_name (as plutôt que de simplement branch_name). Quand vous poussez et tirez le code vers/depuis des dépôts distants, c'est en fait le mécanisme par lequel cela se produit. Par exemple, lorsque vous git push une branche appelée 'building_groups', votre branche va d'abord à origin/building_groups et ensuite au dépôt distant (en fait, c'est une simplification excessive mais assez bonne pour le moment). De même, si vous faites un git fetch building_groups le fichier est extrait est placé dans votre origine/building_groups direction. Vous pouvez ensuite choisir de fusionner cette branche dans votre copie locale. Notre pratique est de toujours faire un git fetch et une fusion manuelle plutôt qu'une simple git pull (ce qui fait les deux ci-dessus en une seule étape).

Fetch

obtention de nouvelles branches: au point initial d'un clone vous aurez toutes les branches. Cependant, si d'autres développeurs ajoutent des branches et les poussent vers la télécommande, il doit y avoir un moyen de "savoir" branches et leurs noms afin d'être en mesure de les tirer vers le bas localement. Cela se fait via un git fetch qui récupérera toutes les branches nouvelles et modifiées dans le dépôt local en utilisant les branches de suivi (par exemple origin/). Une fois fetch ed, on peut git branch --remote pour lister les branches de suivi et git checkout [branch] pour passer réellement à l'une quelconque.

Fusion

Fusion est le processus de combinaison des changements de code de différentes branches, ou à partir de différentes versions de la même branche (par exemple, lors d'une branche locale et à distance sont désynchronisés.). Si l'on a développé le travail dans une branche et que le travail est terminé, prêt et testé, alors il peut être fusionné dans la branche master . Ceci est fait par git checkout master pour passer à la branche master , puis git merge your_branch . La fusion rassemblera tous les différents fichiers et même les modifications différentes aux mêmes fichiers ensemble. Cela signifie qu'il sera effectivement changez le code à l'intérieur des fichiers pour fusionner tous les changements. En faisant le checkout de master il est également recommandé de faire un git pull origin master pour obtenir la toute dernière version du maître à distance fusionné dans votre maître local. Si le maître distant a changé, c.-à-d. moved forward , vous verrez l'information qui reflète que pendant que git pull . Si c'est le cas (maître changé) vous êtes conseillé à git checkout your_branch et puis rebase il à maîtriser afin que vos changements obtiennent effectivement "rejoué" en haut de la "nouvelle" de maître. Puis, continuer avec l'obtention de maître à jour comme indiqué dans le paragraphe suivant.

S'il n'y a pas de conflits, alors master ajoutera les nouveaux changements. S'il y a des conflits, cela signifie que les mêmes fichiers ont des changements autour de lignes de code similaires qu'ils ne peuvent pas fusionner automatiquement. Dans ce cas, git merge new_branch signalera qu'il y a des conflits à résoudre. Vous 'résoudre' en éditant les fichiers (qui sera avoir les deux modifications dans eux), en sélectionnant les modifications que vous voulez, en supprimant littéralement les lignes des modifications que vous ne voulez pas, puis en sauvegardant le fichier. Les changements sont marqués par des séparateurs tels que ======== et <<<<<<<<

une fois que vous aurez résolu tous les conflits, vous aurez à nouveau git add et git commit ces modifications pour poursuivre la fusion (vous obtiendrez des commentaires de git au cours de ce processus pour vous guider). Lorsque le processus ne fonctionne pas bien, vous trouverez ce git merge --abort est très pratique pour réinitialiser les choses.

Interactif complet et en écrasant / réorganisation / retrait s'engage

si vous avez fait beaucoup de petits pas, par exemple si vous commettez du code en tant que 'travail en cours' chaque jour, vous pouvez vouloir" écraser " ces nombreuses petites propagations en quelques plus grandes propagations. Cela peut être particulièrement utile lorsque vous voulez faire des revues de code avec des collègues. Vous ne voulez pas rejouer toutes les 'étapes' que vous avez prises (via commits), vous voulez juste dire ici est l'effet de fin (diff) de tous mes changements pour ce travail dans une commit. Le facteur clé à évaluer lors de la considération de faire ceci est si les commits multiples sont contre le même dossier ou les dossiers plus d'une fois (mieux pour écraser commits dans ce cas). Cela se fait avec l'outil de rebasage interactif. Cet outil vous permet d'écraser les commits, supprimer les commits, reformuler les messages, etc. Par exemple git rebase -i HEAD~10 notez que c'est un ~ pas un - :

Être prudent et d'utiliser cet outil avec précaution'. Faites un squash / delete / reorder à la fois, exit et save that commit, puis retournez l'outil. Si les commits ne sont pas contigus, vous pouvez les réorganiser (puis les écraser au besoin). Vous pouvez effectivement supprimer commet ici aussi, mais vous avez vraiment besoin d'être sûr de ce que vous faites quand vous faites cela!

Fourches

il existe deux approches principales à la collaboration dans les dépôts git. Le premier, détaillé ci-dessus est directement via les branches que les gens tirent et poussent de/à. Ces collaborateurs ont leurs clés ssh enregistrées dans le dépôt distant. Cela leur permettra de pousser directement vers ce dépôt. L'inconvénient est que vous devez maintenir la liste des utilisateurs. L'autre approche-bifurcation-permet à n'importe qui de "bifurquer" le dépôt, en faisant essentiellement une copie locale dans leur propre dépôt git compte. Ils peuvent alors effectuer des modifications et, lorsqu'ils ont terminé, envoyer une "requête pull" (en fait, c'est plutôt une requête "push" et une requête "pull" pour le responsable du dépôt) pour faire accepter le code.

Cette seconde méthode, qui utilise des fourches, ne pas nécessite quelqu'un pour maintenir une liste des utilisateurs pour le dépôt.

Github

github (à distance le dépôt) est une source distante à laquelle vous poussez et retirez normalement les changements engagés si vous avez (ou si vous êtes ajouté) un tel dépôt, donc les sources locales et distantes sont en fait assez distinctes. Une autre façon de penser d'un dépôt distant est que c'est une .structure de répertoire git qui vit sur un serveur distant.

lorsque vous "bifurquez" - dans l'interface GitHub du navigateur Web, vous pouvez cliquer sur - vous créez une copie ("clone") du code dans votre" compte github 1519420920". Il peut être un peu subtil la première fois que vous le faites, alors assurez-vous de vérifier sous quel dépôt une base de code est listée-soit le propriétaire d'origine ou "Fourché de" et vous, par exemple

Une fois que vous avez la copie locale, vous pouvez faire les changements que vous voulez (en les tirant et en les poussant vers une machine locale). Une fois que vous avez terminé, vous soumettez une "requête pull" au propriétaire/administrateur du dépôt original. (sonne fantaisie, mais en fait vous cliquez juste sur ce:- ) et ils 'pull'.

Plus courant pour une équipe travaillant sur le code ensemble est de "cloner" le dépôt (cliquez sur l'icône "Copier" sur l'écran principal du dépôt). Ensuite, tapez localement git clone [paste] cela vous configurera localement et vous pouvez aussi push et pull à l'emplacement GitHub (partagé).

# git
alias gst='git status' # Warning: gst conflicts with gnu-smalltalk (when used).
alias gb='git branch'
alias gco='git checkout'
alias gcob='git checkout -b '
alias ga='git add '
alias gc='git commit'
alias gg='git grep ' #  A great very FAST search option, easier then `find`

git reset --hard origin/master  # You will need to be comfortable doing this!

git checkout -b new_branch_name  # just create a new branch
git add .                      # add the changes files
git commit -m"your message"    # and commit them

git rebase --abort # To abandon interactive rebase and merge issues