J'ai récemment commencé à mettre mon code sous contrôle de version (dans le laboratoire, je travaille, sous SVN, et mes propres codes dans github (évidemment avec git)). Avant d'utiliser le contrôle de version, je faisais quelque chose comme ça. J'avais un dossier avec le nom de la bibliothèque, à l'intérieur de nombreux dossiers avec le numéro de version. Chaque fois que je voulais commencer à travailler sur une version plus récente, je faisais une copie de la dernière version, je changeais le nom pour la nouvelle version et je commençais à l'implémenter.
Cela semble cependant redondant lorsque le dossier est placé sous contrôle de version. En dehors de la redondance, si quelqu'un veut obtenir la dernière version, il téléchargera toutes les versions s'il vient de import
s / clone
s.
Maintenant, je vois de nombreuses façons de le faire avec le contrôle de version, mais comme je suis nouveau dans ce domaine, je ne sais pas lequel serait plus facile à maintenir.
Méthode 1: utiliser des balises
Si je comprenais bien les balises, vous auriez votre branche principale, vous valideriez les modifications que vous auriez et les étiquetteriez avec une version. Ensuite, lorsque vous souhaitez en obtenir une copie de travail, vous obtenez celle avec une certaine balise. (Corrige moi si je me trompe)
Méthode 2: versions de branchement
Dans cette méthode, la branche principale serait la branche de développement. De temps en temps, une version stable est v1.2.0
créée (disons ), vous créez une branche pour cette version et ne vous y engagez jamais. De cette façon, si vous souhaitez télécharger une certaine version, vous obtenez le code de cette branche. Bien que je vous ai dit de ne jamais vous y engager, il peut être possible de corriger des bogues et de vous engager dans la branche d'une ancienne version pour garder l'ancienne version en cours d'exécution. Par exemple, si la version actuelle est v2.0
, mais qu'il y a des gens qui veulent l'utiliser v1.2
, vous pouvez obtenir une autre branche v1.2
, à savoir v1.2.1
et valider les corrections de bogues, ou simplement conserver la version identique à v1.2
et simplement valider les corrections de bogues.
Ainsi, les branches ressembleraient à ceci:
v1.2.1 v1.2.2
/ /
v1.0.0 v1.2.0--------- v2.0.0
/ / /
-------------------------------------- dev
De cette façon, vous avez des branches pour chaque mise à jour de version mineure. (Notez que dans le graphique ci-dessus, v1.2.1 et v1.2.2 ou créés après la sortie de la v2.0.0, ils ne faisaient donc pas partie du développement entre la v1.2.0 et la v2.0.0. Considérez-le comme un support pour les anciennes versions)
Méthode 3: développement de branchement
Cette méthode est l'opposé de la précédente. La branche principale serait la dernière version stable. Chaque fois que vous travaillez sur une nouvelle version, vous créez une branche (pour le développement), travaillez sur votre code et quand il est stable, fusionnez-le avec la branche principale.
Dans ce cas, les branches ressembleraient à ceci:
________ ____ ________________ _____ dev
/ \/ \/ \/
---------------------------------- latest_version
Probablement celui-ci doit être fait en conjonction avec des balises non?
La question!
Quoi qu'il en soit, ma question est la suivante: d'après votre expérience, laquelle de ces méthodes s'avère plus pratique? Existe-t-il une meilleure méthode connue (que je n'ai peut-être pas compris moi-même)? Comment ces choses sont-elles couramment accomplies?