git-reset - En ligne dans le Cloud

PROGRAMME:

Nom

git-reset - Réinitialise le HEAD actuel à l'état spécifié

SYNOPSIS

jet réinitialiser [-q] [ ] [--] ...
jet réinitialiser (--patch | -p) [ ] [--] [ ...]
jet réinitialiser [--doux | --mixed [-N] | --hard | --merge | --keep] [-q] [ ]

DESCRIPTION

Dans le premier et le deuxième formulaire, copiez les entrées de à l'indice. Dans le troisième
formulaire, définissez la tête de branche actuelle (HEAD) sur , en modifiant éventuellement l'index et
arbre de travail pour correspondre. Les / par défaut HEAD dans toutes les formes.

jet réinitialiser [-q] [ ] [--] ...
Ce formulaire réinitialise les entrées d'index pour tous à leur état à . (Ce
n'affecte pas l'arbre de travail ou la branche actuelle.)

Cela signifie que git reset est le contraire de git add .

Après avoir exécuté git reset pour mettre à jour l'entrée d'index, vous pouvez utiliser git-checkout(1)
pour vérifier le contenu de l'index de l'arbre de travail. Alternativement, en utilisant git-
caisse(1) et en spécifiant un commit, vous pouvez copier le contenu d'un chemin hors d'un
s'engager dans l'index et dans l'arbre de travail en une seule fois.

jet réinitialiser (--patch | -p) [ ] [--] [ ...]
Sélectionnez de manière interactive des morceaux dans la différence entre l'index et
(par défaut HEAD). Les morceaux choisis sont appliqués à l'envers à l'index.

Cela signifie que git reset -p est l'opposé de git add -p, c'est-à-dire que vous pouvez l'utiliser pour
réinitialiser sélectivement les gros morceaux. Voir la section « Mode interactif » de git-ajouter(1) pour savoir comment
pour utiliser le mode --patch.

jet réinitialiser [ ] [ ]
Ce formulaire réinitialise la tête de branche actuelle à et met éventuellement à jour l'index
(le réinitialiser à l'arbre de ) et l'arbre de travail en fonction de . Si
est omis, la valeur par défaut est "--mixed". Les doit être l'un des suivants :

--mou, tendre
Ne touche pas du tout au fichier d'index ou à l'arbre de travail (mais réinitialise la tête à
, comme tous les modes). Cela laisse tous vos fichiers modifiés "Modifications apportées à
être commis", comme jet statuts le mettrait.

--mixte
Réinitialise l'index mais pas l'arbre de travail (c'est-à-dire que les fichiers modifiés sont conservés
mais pas marqué pour commit) et rapporte ce qui n'a pas été mis à jour. C'est le
action par défaut.

Si -N est spécifié, les chemins supprimés sont marqués comme intention d'ajouter (voir git-ajouter(1)).

--difficile
Réinitialise l'index et l'arbre de travail. Toute modification des fichiers suivis dans le travail
arbre depuis sont mis au rebut.

--fusionner
Réinitialise l'index et met à jour les fichiers de l'arbre de travail qui sont différents
entre et HEAD, mais conserve ceux qui sont différents entre l'index
et l'arbre de travail (c'est-à-dire qui ont des changements qui n'ont pas été ajoutés). Si un fichier
c'est différent entre et l'index a des changements non organisés, la réinitialisation est
avorté.

En d'autres termes, --merge fait quelque chose comme un jet arbre de lecture -u -m , mais
reporte les entrées d'index non fusionnées.

--garder
Réinitialise les entrées d'index et met à jour les fichiers de l'arborescence de travail qui sont différents
entre et TÊTE. Si un fichier différent entre et TÊTE
a des changements locaux, la réinitialisation est abandonnée.

Si vous souhaitez annuler un commit autre que le dernier sur une branche, git-revert(1) est votre
ami.

OPTIONS

-q, --calme
Soyez silencieux, ne signalez que les erreurs.

EXEMPLES

Annuler l'ajout

$ modifier (1)
$ git add frotz.c filfre.c
$ mailx (2)
$ git réinitialiser (3)
$ git pull git://info.example.com/nitfol (4)

1. Vous travaillez avec bonheur sur quelque chose et trouvez que les changements dans ces fichiers sont dans
en bon ordre. Vous ne voulez pas les voir lorsque vous exécutez "git diff", car vous prévoyez de
travailler sur d'autres fichiers et les modifications apportées à ces fichiers sont gênantes.
2. Quelqu'un vous demande de tirer, et les changements semblent dignes d'être fusionnés.
3. Cependant, vous avez déjà sali l'index (c'est-à-dire que votre index ne correspond pas au HEAD
s'engager). Mais vous savez que la traction que vous allez faire n'affecte pas frotz.c ou
filfre.c, donc vous annulez les modifications d'index pour ces deux fichiers. Vos changements dans le travail
l'arbre y reste.
4. Ensuite, vous pouvez extraire et fusionner, en laissant les modifications frotz.c et filfre.c toujours dans le
arbre de travail.

Annuler un commit et refaire

$ git commit...
$ git reset --soft HEAD^ (1)
$ modifier (2)
$ git commit -a -c ORIG_HEAD (3)

1. Cela se fait le plus souvent lorsque vous vous souvenez que ce que vous venez de commettre est incomplet,
ou vous avez mal orthographié votre message de validation, ou les deux. Laisse l'arbre de travail tel qu'il était avant
"réinitialiser".
2. Apportez des corrections aux fichiers d'arborescence de travail.
3. "reset" copie l'ancienne tête dans .git/ORIG_HEAD ; refaire le commit en commençant par son
message de journal. Si vous n'avez pas besoin de modifier davantage le message, vous pouvez donner l'option -C
à la place.

Voir aussi l'option --amend pour git-commit (1).

Annuler un commit, en faire une branche thématique

$ git branche sujet/wip (1)
$ git réinitialiser --hard HEAD~3 (2)
$ git checkout sujet/wip (3)

1. Vous avez fait quelques commits, mais réalisez qu'ils étaient prématurés pour être dans le "master"
branche. Vous voulez continuer à les peaufiner dans une branche thématique, alors créez "topic/wip"
dérivation de la HEAD actuelle.
2. Rembobiner la branche master pour se débarrasser de ces trois commits.
3. Passez à la branche "sujet/wip" et continuez à travailler.

Annuler les commits de façon permanente

$ git commit...
$ git réinitialiser --hard HEAD~3 (1)

1. Les trois derniers commits (HEAD, HEAD^ et HEAD~2) étaient mauvais et vous ne voulez pas
jamais les revoir. Faire pas faites-le si vous avez déjà donné ces commits à
quelqu'un d'autre. (Voir la section « RÉCUPÉRATION À PARTIR D'UN REBASE AMONT » dans git-rebase(1) pour
les implications de le faire.)

Annuler une fusion ou une extraction

$ git tirer (1)
Nitfol à fusion automatique
CONFLIT (contenu) : fusionner le conflit dans nitfol
Échec de la fusion automatique ; résoudre les conflits, puis valider le résultat.
$ git réinitialiser --hard (2)
$ git pull . sujet/branche (3)
Mise à jour de 41223... à 13134...
Avance rapide
$ git réinitialiser --hard ORIG_HEAD (4)

1. Essayer de mettre à jour en amont a entraîné de nombreux conflits ; tu n'étais pas prêt
passer beaucoup de temps à fusionner maintenant, alors vous décidez de le faire plus tard.
2. "pull" n'a pas fait de commit de fusion, donc "git reset --hard" qui est un synonyme de "git
reset --hard HEAD" efface le désordre du fichier d'index et de l'arbre de travail.
3. Fusionner une branche thématique dans la branche actuelle, ce qui a entraîné une avance rapide.
4. Mais vous avez décidé que la branche thématique n'est pas encore prête pour la consommation publique.
"pull" ou "merge" laisse toujours la pointe d'origine de la branche actuelle dans ORIG_HEAD,
donc réinitialiser dur ramène votre fichier d'index et l'arbre de travail à cela
state et réinitialise la pointe de la branche à ce commit.

Annuler une fusion ou tirer à l'intérieur d'un arbre de travail sale

$ git tirer (1)
Nitfol à fusion automatique
Fusion faite par récursif.
nitrofol | 20 +++++----

$ git réinitialiser --merge ORIG_HEAD (2)

1. Même si vous pouvez avoir des modifications locales dans votre arbre de travail, vous pouvez dire en toute sécurité
"git pull" quand on sait que le changement dans l'autre branche ne se chevauche pas avec
Eux.
2. Après avoir inspecté le résultat de la fusion, vous constaterez peut-être que le changement dans l'autre
branche n'est pas satisfaisante. L'exécution de "git reset --hard ORIG_HEAD" vous permettra de revenir à
où vous étiez, mais il supprimera vos modifications locales, ce que vous ne voulez pas. " zut
reset --merge" conserve vos modifications locales.

Flux de travail interrompu
Supposons que vous soyez interrompu par une demande de réparation urgente alors que vous êtes au milieu d'une
grand changement. Les fichiers de votre arbre de travail ne sont pas encore en forme pour être validés,
mais vous devez accéder à l'autre branche pour une correction de bogue rapide.

$ git checkout feature ;# vous travailliez dans la branche "feature" et
$ travail travail travail ;# a été interrompu
$ git commit -a -m "instantané WIP" (1)
$ git checkout maître
$ fixe fixe fixe
$ git commit ; # commit avec un vrai journal
$ git checkout
$ git reset --soft HEAD^ ;# retourne à l'état WIP (2)
$ git réinitialiser (3)

1. Ce commit sera détruit, donc un message de journal jetable est OK.
2. Cela supprime le WIP commit à partir de l'historique des commits et définit votre arbre de travail sur
l'état juste avant de prendre cet instantané.
3. À ce stade, le fichier d'index contient toujours toutes les modifications WIP que vous avez validées en tant que
instantané WIP. Cela met à jour l'index pour afficher vos fichiers WIP comme non validés.

Voir aussi git-cache (1).

Réinitialiser un seul fichier dans l'index
Supposons que vous ayez ajouté un fichier à votre index, mais que vous décidiez plus tard que vous ne voulez pas ajouter
à votre engagement. Vous pouvez supprimer le fichier de l'index tout en conservant vos modifications
avec git reset.

$ git réinitialiser -- frotz.c (1)
$ git commit -m "Commit les fichiers dans l'index" (2)
$ git ajouter frotz.c (3)

1. Cela supprime le fichier de l'index tout en le conservant dans le répertoire de travail.
2. Cela valide toutes les autres modifications de l'index.
3. Ajoute à nouveau le fichier à l'index.

Conserver les modifications dans l'arbre de travail tout en supprimant certains commits précédents
Supposons que vous travaillez sur quelque chose et que vous le validez, puis vous continuez à travailler
un peu plus, mais maintenant vous pensez que ce que vous avez dans votre arbre de travail devrait être dans
une autre branche qui n'a rien à voir avec ce que vous avez commis précédemment. Vous pouvez
démarrez une nouvelle branche et réinitialisez-la tout en conservant les modifications dans votre arbre de travail.

$ début de la balise git
$ git checkout -b branche1
$ modifier
$ git commit... (1)
$ modifier
$ git checkout -b branche2 (2)
$ git reset --keep start (3)

1. Cela valide vos premières modifications dans branch1.
2. Dans le monde idéal, vous auriez pu réaliser que le commit précédent n'appartenait pas
au nouveau sujet lorsque vous avez créé et basculé vers branch2 (c'est-à-dire "git checkout -b
branch2 start"), mais personne n'est parfait.
3. Mais vous pouvez utiliser "reset --keep" pour supprimer le commit indésirable après être passé à
"branche2".

DISCUSSION

Les tableaux ci-dessous montrent ce qui se passe lors de l'exécution :

git reset --option cible

pour réinitialiser le HEAD à un autre commit (cible) avec les différentes options de réinitialisation en fonction de
l'état des fichiers.

Dans ces tableaux, A, B, C et D sont des états différents d'un fichier. Par exemple, le premier
ligne du premier tableau signifie que si un fichier est à l'état A dans l'arbre de travail, à l'état B
dans l'index, à l'état C dans HEAD et à l'état D dans la cible, puis "git reset --soft
target" laissera le fichier dans l'arbre de travail à l'état A et dans l'index à l'état B. Il
réinitialise (c'est-à-dire déplace) le HEAD (c'est-à-dire la pointe de la branche actuelle, si vous en êtes sur une) à
"cible" (qui a le fichier dans l'état D).

index de travail HEAD index de travail cible HEAD
-------------------------------------------------- -
ABCD --ABD souple
--mixte AJOUTER
--hard DDD
--merge (non autorisé)
--keep (interdit)

index de travail HEAD index de travail cible HEAD
-------------------------------------------------- -
ABCC --ABC doux
--ACC mixte
--hard CCC
--merge (non autorisé)
--garder ACC

index de travail HEAD index de travail cible HEAD
-------------------------------------------------- -
BBCD --soft BBD
--BDD mixte
--hard DDD
--fusion DDD
--keep (interdit)

index de travail HEAD index de travail cible HEAD
-------------------------------------------------- -
BBCC --soft BBC
--BCC mixte
--hard CCC
--fusionner CCC
--garder Cci

index de travail HEAD index de travail cible HEAD
-------------------------------------------------- -
BCCD --BCD souple
--BDD mixte
--hard DDD
--merge (non autorisé)
--keep (interdit)

index de travail HEAD index de travail cible HEAD
-------------------------------------------------- -
BCCC --Cci souple
--BCC mixte
--hard CCC
--fusion Cci
--garder Cci

"reset --merge" est destiné à être utilisé lors de la réinitialisation d'une fusion en conflit. Toute fusion
l'opération garantit que le fichier d'arbre de travail impliqué dans la fusion ne
avoir un changement local par rapport à l'index avant qu'il ne démarre, et qu'il écrive le résultat dans le
arbre de travail. Donc, si nous voyons une certaine différence entre l'indice et la cible et aussi
entre l'index et l'arbre de travail, cela signifie que nous ne repartons pas d'un
déclarer qu'une opération de fusion est partie après avoir échoué avec un conflit. C'est pourquoi nous refusons
--merge option dans ce cas.

"reset --keep" est destiné à être utilisé lors de la suppression de certains des derniers commits dans le
branche tout en conservant les modifications dans l'arbre de travail. S'il pouvait y avoir des conflits entre les
les changements dans le commit que nous voulons supprimer et les changements dans l'arbre de travail que nous voulons
garder, la réinitialisation est interdite. C'est pourquoi il est interdit s'il y a les deux changements
entre l'arbre de travail et HEAD, et entre HEAD et la cible. Pour plus de sécurité, c'est aussi
interdit lorsqu'il y a des entrées non fusionnées.

Les tableaux suivants montrent ce qui se passe lorsqu'il y a des entrées non fusionnées :

index de travail HEAD index de travail cible HEAD
-------------------------------------------------- -
XUAB --soft (interdit)
--mixte XBB
--dur BBB
--fusionner BBB
--keep (interdit)

index de travail HEAD index de travail cible HEAD
-------------------------------------------------- -
XUAA --soft (non autorisé)
--XAA mixte
--dur AAA
--fusionner AAA
--keep (interdit)

X signifie n'importe quel état et U signifie un index non fusionné.

GIT

Une partie de l' jet(1) Suite

Utilisez git-reset en ligne en utilisant les services onworks.net