Générateur de Commandes Git Gratuit

Générez les commandes Git courantes avec une interface visuelle. Gratuit, rapide et entièrement dans votre navigateur, sans inscription.

Mis à jour le

Share:
Home/Developer Tools/Git Command Generator

Git Command Generator

Generate common Git commands with a visual interface. Perfect for learning Git.

Select Operation

Basic
Branching
Remote
History & Recovery
Advanced

Commit Changes
Basic

Record changes to the repository

Generated Command

$ git commit -m "Your commit message"
Shell Alias
alias gcommit='git commit -m "Your commit message"'
Undo & Fix
Branching
Cleanup
Collaboration
Release & Deploy

Undo last commit (keep changes)
Undo & Fix

Undo the most recent commit but keep your changes staged

$ git reset --soft HEAD~1

This moves HEAD back one commit, leaving your changes staged. You can then edit files and commit again.

Undo last commit (discard changes)
Undo & Fix

Completely remove the last commit and all its changes

$ git reset --hard HEAD~1

WARNING: This permanently deletes the last commit and all uncommitted changes. Use git reflog to recover if needed.

Amend last commit message
Undo & Fix

Change the message of your most recent commit

$ git commit --amend -m "New commit message"

Replaces the last commit message. Only do this if you haven't pushed yet, as it rewrites history.

Unstage all files
Undo & Fix

Remove all files from the staging area

$ git reset HEAD

Unstages all files without modifying your working directory. Files remain modified but are no longer staged.

Discard all local changes
Undo & Fix

Reset working directory to match the last commit

$ git checkout -- .
# Or use: git restore .

Discards all uncommitted changes in tracked files. Untracked files are not affected.

Recover deleted branch
Undo & Fix

Restore a branch that was accidentally deleted

$ git reflog
# Find the commit hash, then:
$ git checkout -b recovered-branch <commit-hash>

Use reflog to find the last commit of the deleted branch, then create a new branch at that commit.

Create feature branch
Branching

Start working on a new feature from main

$ git checkout main
$ git pull origin main
$ git checkout -b feature/my-feature

Ensures you start from the latest main branch, then creates and switches to a new feature branch.

Squash last N commits
Branching

Combine multiple commits into one

$ git reset --soft HEAD~3
$ git commit -m "Combined commit message"

Soft resets N commits back, keeping all changes staged, then creates one new commit. Replace 3 with your number.

Rebase feature on main
Branching

Update your feature branch with latest main changes

$ git checkout feature/my-feature
$ git fetch origin
$ git rebase origin/main

Replays your feature commits on top of the latest main. Resolve conflicts if any arise, then continue.

Cherry-pick a commit
Branching

Apply a specific commit from another branch

$ git log --oneline other-branch
# Find the commit hash, then:
$ git cherry-pick <commit-hash>

Creates a new commit on your current branch with the same changes as the specified commit.

Remove untracked files
Cleanup

Clean up untracked files and directories

$ git clean -n
# Preview first, then:
$ git clean -fd

The -n flag shows what would be deleted. The -f flag forces deletion and -d includes directories.

Remove file from tracking
Cleanup

Stop tracking a file but keep it locally

$ git rm --cached path/to/file
$ echo "path/to/file" >> .gitignore
$ git commit -m "Remove file from tracking"

Removes the file from Git tracking without deleting it from your filesystem. Add it to .gitignore to prevent re-adding.

Prune remote branches
Cleanup

Remove local references to deleted remote branches

$ git fetch --prune
$ git branch -vv | grep "gone"
# Delete stale branches:
$ git branch -d <branch-name>

Fetches and removes references to remote branches that no longer exist, then shows stale local branches.

Resolve merge conflicts
Collaboration

Steps to handle merge conflicts

$ git status
# Edit conflicted files, then:
$ git add .
$ git commit -m "Resolve merge conflicts"

Check which files have conflicts, edit them to resolve the markers (<<<< ==== >>>>), stage and commit.

Stash and switch branches
Collaboration

Save work temporarily to switch branches

$ git stash -u -m "WIP: my changes"
$ git checkout other-branch
# When done, switch back:
$ git checkout original-branch
$ git stash pop

Stashes all changes (including untracked), switches branch, and later restores them with stash pop.

Pull with rebase
Collaboration

Sync with remote without creating merge commits

$ git pull --rebase origin main

Fetches changes and replays your local commits on top. Keeps a cleaner, linear history than merge.

Create a release tag
Release & Deploy

Tag a release version with annotation

$ git tag -a v1.0.0 -m "Release version 1.0.0"
$ git push origin v1.0.0

Creates an annotated tag with a message and pushes it to the remote. Use semantic versioning.

Create release archive
Release & Deploy

Create a zip archive of the current state

$ git archive --format=zip --output=release.zip HEAD

Creates a zip file containing all tracked files at the current HEAD, without the .git directory.

Bisect to find a bug
Release & Deploy

Binary search through commits to find when a bug was introduced

$ git bisect start
$ git bisect bad HEAD
$ git bisect good v1.0.0
# Test each commit, then:
$ git bisect good # or git bisect bad
# When done:
$ git bisect reset

Git checks out commits between good and bad. You test each one and mark it. Git narrows down the offending commit.

Questions Fréquentes

Qu'est-ce que le Git Command Generator ?

Le Git Command Generator est un outil en ligne gratuit qui vous aide à construire les commandes Git courantes via une interface visuelle, sans avoir à mémoriser la syntaxe.

Le Git Command Generator est-il gratuit ?

Oui, il est entièrement gratuit et ne nécessite aucune inscription. Il fonctionne entièrement dans votre navigateur.

Convient-il aux débutants en Git ?

Oui, le Git Command Generator est parfait pour les débutants qui souhaitent apprendre les commandes Git, ainsi que pour les développeurs expérimentés qui ont besoin d'une référence rapide.

Mes données sont-elles en sécurité avec cet outil ?

Absolument. Le Git Command Generator traite tout côté client, dans votre navigateur. Aucune donnée n'est envoyée ni stockée sur un serveur. Votre contenu reste privé sur votre appareil à tout moment.

Le Git Command Generator fonctionne-t-il sur les appareils mobiles ?

Oui, le Git Command Generator est entièrement responsive et fonctionne sur smartphones et tablettes. Vous pouvez l'utiliser sur n'importe quel appareil doté d'un navigateur web moderne, sans aucune application à télécharger.

Dois-je créer un compte pour utiliser cet outil ?

Aucun compte ni inscription n'est nécessaire. Ouvrez simplement le Git Command Generator dans votre navigateur et commencez à l'utiliser immédiatement. Il n'y a ni page d'inscription ni restriction d'utilisation.

Quels langages de programmation ou formats prend-il en charge ?

Le Git Command Generator prend en charge un large éventail de formats et de langages populaires. Consultez l'interface de l'outil pour la liste complète des options prises en charge.

Comment utiliser le Git Command Generator ?

Saisissez simplement votre contenu dans le champ prévu, ajustez les paramètres selon vos préférences, et l'outil le traitera instantanément. Vous pouvez ensuite copier le résultat dans le presse-papiers ou le télécharger.

Quels navigateurs sont pris en charge ?

Le Git Command Generator fonctionne dans tous les navigateurs modernes, dont Chrome, Firefox, Safari, Edge et Opera. Pour une expérience optimale, utilisez la dernière version de votre navigateur préféré.

Quelle est la différence entre git push --force et --force-with-lease ?

Les deux écrasent la branche distante avec votre historique local, ce dont vous avez généralement besoin après un rebase ou un amend de commit. La différence tient à la sécurité. Un simple --force pousse quoi qu'il arrive : si un collègue a poussé de nouveaux commits depuis votre dernier fetch, --force les efface silencieusement. --force-with-lease vérifie d'abord que la branche distante pointe bien où vous le pensez ; si quelqu'un d'autre a poussé entre-temps, le push est rejeté au lieu d'écraser son travail. Cela fait de --force-with-lease le choix par défaut le plus sûr sur les branches partagées. Ce générateur propose les deux options sur l'opération push et signale le simple --force comme dangereux, tout en mettant en avant, juste à côté, la variante plus sûre avec lease. Choisissez push, activez l'option souhaitée, et copiez la commande exacte à coller dans votre propre terminal.

Comment annuler le dernier commit dans Git tout en conservant mes modifications ?

Utilisez un reset soft ou mixed plutôt qu'un reset hard. Exécuter git reset --soft HEAD~1 supprime le dernier commit mais laisse toutes les modifications indexées, prêtes à être recommitées ; git reset HEAD~1 (un reset mixed, le comportement par défaut) conserve les modifications dans votre répertoire de travail mais les désindexe. L'essentiel est d'éviter git reset --hard HEAD~1, qui supprime le commit et abandonne définitivement ces modifications, sans corbeille pour les récupérer. Si vous avez seulement besoin de corriger le message de commit ou d'ajouter un fichier oublié, git commit --amend est souvent plus propre qu'un reset. Ce générateur inclut l'opération reset avec les modes soft, mixed et hard, marque l'option hard comme dangereuse, et explique précisément ce que fait chacune à votre arbre de travail avant que vous ne la copiiez.

Que fait git stash et comment récupérer mes modifications ?

git stash enregistre vos modifications non commitées sur une pile temporaire et remet votre répertoire de travail dans un état propre, ce qui est pratique quand vous devez changer de branche ou récupérer des mises à jour sans commiter un travail à moitié terminé. Vos modifications ne sont pas perdues : elles restent sur la pile de stash jusqu'à ce que vous les restauriez. Pour les récupérer, exécutez git stash pop, qui réapplique le stash le plus récent et le retire de la pile, ou git stash apply, qui le réapplique tout en conservant une copie sur la pile. Utilisez git stash list pour voir tout ce que vous avez enregistré. Faites attention avec git stash clear, qui supprime définitivement tous les stashs. Ce générateur couvre stash, pop, apply, list et clear, en signalant l'option destructrice clear afin que vous sachiez quelles actions sont irréversibles.

Qu'est-ce qu'un clone superficiel et quand utiliser --depth 1 ?

Un clone superficiel copie un dépôt sans son historique complet de commits. Ajouter --depth 1 à git clone ne récupère que le commit le plus récent de chaque branche, au lieu de la totalité de l'historique depuis la création du projet, ce qui réduit considérablement la taille et le temps de téléchargement pour les gros dépôts. C'est idéal pour les pipelines d'intégration continue, les builds Docker, et toute situation où vous avez seulement besoin du code actuel sans vous soucier de l'historique passé. Le compromis est que les commandes qui s'appuient sur l'historique, comme git log sur d'anciens commits ou git blame remontant loin dans le passé, n'auront pas les données nécessaires tant que vous n'aurez pas désaplati (unshallow) le clone. L'opération clone de ce générateur inclut l'option superficielle --depth 1 aux côtés d'une --branch précise et d'une récupération récursive des sous-modules avec --recursive, pour assembler la commande de clonage exacte et la copier en un clic.

Comment fusionner (squash) plusieurs commits en un seul avant un merge ?

Le squash combine plusieurs commits en un seul commit propre, ce qui garde un historique de projet lisible avant de fusionner une branche de fonctionnalité. L'approche la plus courante est un rebase interactif, git rebase -i HEAD~N, où N correspond au nombre de commits à revoir en remontant ; vous marquez ensuite les commits à regrouper. Autre possibilité, git merge --squash nom-de-branche indexe l'ensemble des modifications d'une branche comme un seul bloc, afin de créer un unique commit sur la branche cible sans importer les commits individuels. Le squash réécrit l'historique : évitez donc de le faire sur des commits déjà poussés vers une branche partagée, à moins de vous coordonner avec votre équipe. Ce générateur inclut l'opération merge avec une option --squash et explique ce qu'elle fait, vous permettant de construire la commande et de la coller dans votre terminal une fois le résultat validé.

Embed This Tool

Add a free, live version of this widget to your own website or blog post — it runs entirely in your visitors' browsers, with a credit link back to The Toolbox.

Copy & paste this HTML
<iframe src="https://getthetoolbox.com/embed/git-command-generator" title="Free Git Command Generator — The Toolbox" width="100%" height="320" style="max-width:480px;border:1px solid #e2e8f0;border-radius:12px" loading="lazy"></iframe>
<p style="font-size:12px;margin:4px 0 0"><a href="https://getthetoolbox.com/developer-tools/git-command-generator?utm_source=embed&utm_medium=widget" target="_blank" rel="noopener">Free Git Command Generator</a> by The Toolbox</p>

À propos du générateur de commandes Git

Le générateur de commandes Git construit pour vous des commandes Git correctes grâce à une interface visuelle, pour que vous n'ayez jamais à fouiller les pages de manuel ni à deviner l'ordre des options. Choisissez une opération, renseignez un ou deux champs, activez les options souhaitées, et la commande exacte s'assemble sous vos yeux dans un aperçu façon terminal, prête à copier-coller. Il s'adresse à quiconque utilise Git sans vouloir mémoriser sa syntaxe : débutants qui apprennent les bases, étudiants qui manipulent leur premier dépôt, et développeurs expérimentés qui ont juste besoin d'un rappel rapide sur une option utilisée une fois par mois.

Tout s'exécute dans votre navigateur. Aucune inscription, aucun envoi de données : la commande, le nom de branche ou le message de commit que vous saisissez ne quittent jamais votre appareil. L'outil génère le texte localement et fonctionne hors connexion une fois la page chargée.

Ce que vous pouvez générer

Le générateur couvre le flux de travail Git du quotidien ainsi que les opérations que l'on recherche le plus souvent. Les commandes sont regroupées par catégories pour parcourir la liste plutôt que de défiler sans fin :

  • De baseclone, init, add, commit, push, pull
  • Branchesbranch, checkout/switch, merge, rebase
  • Dépôt distantfetch, remote, et le suivi des branches amont
  • Historiquelog, diff, reset, stash, tag, reflog
  • Avancécherry-pick, revert, clean, bisect, blame, worktree, archive

Chaque opération affiche ses propres champs de formulaire et un ensemble d'options activables. Le clonage, par exemple, propose un clone superficiel avec --depth 1, une --branch précise, ou la récupération récursive des sous-modules avec --recursive ; commit propose --amend, -a, la signature GPG avec -S, et bien plus. Une courte explication en langage clair accompagne chaque commande, si bien que l'outil fait aussi office d'aide-mémoire qui précise ce que fait réellement chaque option.

Des recettes rapides pour les tâches courantes

Au-delà des commandes individuelles, le générateur propose des recettes toutes prêtes pour les questions les plus recherchées : annuler le dernier commit en conservant les modifications, abandonner les changements locaux, écraser (squash) les N derniers commits, récupérer une branche supprimée grâce à reflog, rebaser une branche de fonctionnalité sur main, nettoyer les branches distantes obsolètes, et résoudre des conflits de fusion. Ces recettes associent la bonne commande à une note précise sur ce qu'elle va faire à votre arbre de travail, ce qui enlève beaucoup d'anxiété autour des aspects les moins indulgents de Git.

Des garde-fous intégrés pour les commandes dangereuses

Certaines commandes Git réécrivent l'historique ou suppriment du travail de façon définitive, et le générateur les signale avant que vous n'exécutiez quoi que ce soit. Les options destructrices — git push --force, git reset --hard, git clean -f, la suppression forcée d'une branche avec -D, ou l'abandon des modifications locales lors d'un checkout — sont marquées comme dangereuses et affichent un avertissement dans l'aperçu. Quelques faits à garder en tête :

  • git reset --hard supprime toutes les modifications non commitées sans corbeille de récupération ; le travail indexé comme non indexé disparaît.
  • git push --force écrase l'historique distant. Préférez --force-with-lease, que l'outil propose également, pour éviter d'écraser les commits d'un collègue.
  • git clean -f supprime définitivement les fichiers non suivis ; lancer -n au préalable montre ce qui serait supprimé sans rien toucher.

L'objectif est de vous permettre de générer une commande puissante tout en comprenant, au même endroit, l'étendue de ses conséquences.

Comment l'utiliser et copier le résultat

Recherchez ou filtrez pour trouver une opération, saisissez les valeurs nécessaires (une URL de dépôt, un nom de branche, un message de commit), et activez les options voulues. La commande se met à jour en temps réel. Quand le résultat vous convient, copiez-le en un clic — ou copiez-le sous forme d'alias shell, que l'outil génère automatiquement afin que vous puissiez glisser un raccourci directement dans votre .zshrc ou .bashrc. Comme le générateur de commandes Git se contente de produire du texte et n'exécute jamais rien, vous pouvez expérimenter librement, coller le résultat dans votre propre terminal, et garder le plein contrôle sur le moment et l'endroit où il s'exécute.