Vous guide pas à pas à travers les commandes git les plus couramment utilisées en 10 minutes

Essentiellement, Git peut enregistrer les modifications apportées au texte, mais sa définition est un système de contrôle de version. Il y a de fortes chances que vous ayez déjà utilisé git d'une manière ou d'une autre : en raison de sa nature distribuée, il s'agit du standard de facto pour le contrôle de version du code, par opposition à Apache Subversion (SVN) centralisé.

Installez git

Pour vérifier si Git est installé, exécutez dans le terminal :

$ git version
git version 2.27.0.rc1.windows.1

S'il n'est pas installé, suivez les instructions sur https://git-scm.com/downloads. Les utilisateurs Mac peuvent l'installer en utilisant Brew : Brew Install git.

Configurer git

Nous n'avons besoin de configurer que quelques éléments

git config --global user.name "前端小智" && # 你的名字
git config --global user.email johndoe@example.com && # 你的邮箱
git config --global init.defaultbranch main # 默认分支名称，与GitHub兼容

Vous pouvez utiliser la commande suivante pour afficher la configuration globale actuelle

git config --global --list
# Type ":q" to close

git stocke la configuration en texte brut Si vous souhaitez la modifier directement, vous pouvez le modifier directement dans ~/.gitconfig Ou éditer la configuration globale dans ~/.config/git/config.

Comme le suggère la commande, la suppression de --global étendra la portée de ces commandes au dossier actuel. Mais pour tester cela, nous avons besoin d'un référentiel.

Créer un nouveau référentiel

Un référentiel est simplement un dossier qui contient tout ce que nous voulons suivre. Créé par commande :

mkdir gitexample && 
cd gitexample && 
git init
# gitexample git:(main)

Cette commande crée un dossier .git dans le dossier gitexample. Ce dossier .git caché est le référentiel : toutes les configurations et modifications locales sont stockées ici.

Changer

Créez quelque chose dans le référentiel :

echo "Hello, Git " >> hello.txt

Exécutez git status et nous verrons le fichier non suivi nouvellement créé.

git status
# On branch main
# 
# No commits yet
# 
# Untracked files:
#  (use "git add <file>..." to include in what will be committed)
#   hello.txt
#
# nothing added to commit but untracked files present (use "git add" to track)

Selon la suggestion rapide, nous ajoutons le fichier :

git add .

Si nous ne voulons pas que tous les fichiers soient ajoutés, nous pouvons utiliser

git add hello.txt

Si vous vérifiez l'état du référentiel maintenant, vous verrez que le le fichier a été ajouté (c'est-à-dire mis en scène), mais il n'a pas encore été soumis.

git status
# On branch main
# 
# No commits yet
# 
# Changes to be committed:
#  (use "git rm --cached <file>..." to unstage)
#   new file:   hello.txt

Pour documenter ces changements, validons-le.

git commit -m "Add hello.txt"
# [main (root-commit) a07ee27] Adds hello.txt
# 1 file changed, 2 insertions(+)
# create mode 100644 hello.txt

git commit -m a195b89f7911c4d642d1f1149788e37a est une commande courte Vous pouvez utiliser git commit pour ouvrir un éditeur (principalement vim) et fournir une description détaillée du commit.

Vérifiez l'historique des commits :

git log
# Author: qq449245884 <44924566884@qq.com>
# Date:   Sat Jul 17 14:57:24 2021 +0800
#
#    Add hello.txt
#

Créez une branche

Dans de nombreuses situations, il est utile d'avoir une version indépendante de votre code initial : par exemple, lorsque vous testez une fonctionnalité dont vous n'êtes pas sûr, ou lorsque vous travaillez ensemble pour éviter conflit de codes. C’est exactement ce qu’est une branche git : elle se développe à partir d’un moment spécifique de l’histoire.

Pour créer une branche, exécutez git branch NAME, pour changer de branche, exécutez git checkout NAME. Ou simplement

git checkout -b dev # 切换到一个名为“dev”的新分支
# Switched to a new branch 'dev'
# gitexample git:(dev)

nous modifions quelque chose dans le fichier Hello.txt et validons les modifications :

echo "\nHello, Git Branch" >> hello.txt &&
git commit -am "Change hello.txt"

Maintenant, passez à la branche master :

git checkout main &&
cat hello.txt
# Switched to branch 'main'
# Hello, Git

Comme vous pouvez le voir, le contenu du fichier est toujours le même qu'avant. Pour comparer les branches que nous pouvons exécuter.

git diff dev
# diff --git a/hello.txt b/hello.txt
# index 360c923..b7aec52 100644
# --- a/hello.txt
# +++ b/hello.txt
# @@ -1,3 +1 @@
# Hello, Git
# -
# -Hello, Git Branch
# (END)
# type ":q" to close

Apportons des modifications dans la branche master :

echo "\nHi from Main Branch" >> hello.txt &&
git commit -am "Change hello.txt from main"
# [main 9b60c4b] Change hello.txt from main
# 1 file changed, 2 insertions(+)

Essayons maintenant de fusionner ces modifications.

git merge dev
# Auto-merging hello.txt
# CONFLICT (content): Merge conflict in hello.txt
# Automatic merge failed; fix conflicts and then commit the result.

Comme le fichier a été modifié deux fois au même endroit, nous avons eu un conflit. Jetez un œil à ce fichier

cat hello.txt
<<<<<<< HEAD
Hello, Git
Hi from Main Branch
=======
Hello, Git
>>>>>>> dev

Il existe également une commande pour afficher les modifications individuellement :

git diff --ours # :q to close 
git diff --theirs #:q to close

Vous pouvez modifier manuellement le fichier et valider les modifications, mais imaginons que nous n'en voulons qu'une seule version. Commençons par abandonner la fusion.

git merge --abort

et relancer la fusion avec la stratégie "leur", ce qui signifie qu'en cas de conflit, nous utiliserons ce à quoi la branche entrante s'accroche.

git merge -X theirs dev
# Auto-merging hello.txt
# Merge made by the 'recursive' strategy.
# hello.txt | 5 +----
# 1 file changed, 1 insertion(+), 4 deletions(-)

Le contraire de cette stratégie est « la nôtre ». La fusion de ces deux modifications nécessite une édition manuelle (ou l'utilisation de git mergetool).

Affichez une liste de toutes les exécutions de branche

git branch # type :q to close
#  dev
# * main

Enfin, supprimez la branche et exécutez :

git branch -d dev
# Deleted branch dev (was 6259828).

Réinitialiser la branche

La branche "grandit" à partir d'un certain point dans l'historique de git, le rebase permet de modifier ce point. Créons une autre branche et ajoutons quelques modifications à hello.txt.

git checkout -b story &&
echo "Once upon a time there was a file">>story.txt &&
git add story.txt &&
git commit -m "Add story.txt"
# Switched to a new branch 'story'
# [story eb996b8] Add story.txt
# 1 file changed, 1 insertion(+)
# create mode 100644 story.txt

Maintenant, nous retournons à la branche master et ajoutons des modifications :

git checkout main &&
echo "Other changes" >> changes.txt &&
git add changes.txt &&
git commit -m "Add changes.txt"

Réinitialisez les modifications que nous avons apportées dans la branche principale à l'histoire :

git checkout story &&
git rebase main
# Successfully rebased and updated refs/heads/story.

Vous pouvez voir que les nouveaux fichiers créés dans la branche principale sont ajoutés à la branche story bifurquer.

ls
# changes.txt hello.txt   story.txt

Remarque : Ne rebasez pas les branches que d'autres ont pu utiliser, comme la branche master. N'oubliez pas non plus que chaque opération historique sur le référentiel distant doit forcer l'application de ces modifications.

Remote Repository

Si vous n'en avez pas encore, créez un compte GitHub, connectez-vous et créez un nouveau référentiel vide (privé ou public).

En supposant que le nom du référentiel est "exemple", exécutez la commande suivante (remplacez-la par votre nom d'utilisateur).

git remote add origin git@github.com:USERNAME/example.git &&
git push -u origin main

Vous pouvez actualiser la page et voir les fichiers dans la branche master. Pour pousser toutes les branches locales vers le référentiel distant, exécutez.

git push --all origin

Modifions quelque chose sur GitHub : cliquez simplement sur n'importe quel fichier et sur l'icône en forme de crayon. Ajoutez une ligne du texte de votre choix et appuyez sur "Soumettre les modifications".

Exécutez cette commande localement pour obtenir les modifications à distance. [Recommandé : Tutoriel Git]

git checkout main &&
git pull

Gérer les modifications non validées

Si vous souhaitez enregistrer vos modifications locales pour une utilisation ultérieure, vous pouvez utiliser git stash.

echo "Changes" >> hello.txt &&
git stash

Vous pouvez désormais utiliser les commandes suivantes pour vérifier, appliquer ou ignorer ces modifications.

git stash list
# stash@{0}: WIP on main: 92354c8 Update changes.txt
git stash pop # 应用更改
git stash drop # 撤销修改

你可以使用 stash 编号，即git stash pop 0来应用一个特定的储藏库，或者git stash drop 0来撤销。

如果你想放弃所有的本地修改，只需恢复版本库到最后提交的修改，请运行。

git restore .

管理提交的更改

一旦你创建了一个提交，这个变化就会保存在本地的git历史中。如前所述，所有影响远程历史的修改都需要git push --force。以下所有命令都要记住这一点。

我们从编辑最后的提交信息开始。

git commit --amend # type :wq to save and close
# Press "i" to edit, "Esc" to stop editing

我们把一切重设到最开始怎么样？

要找到第一次提交的ID，请运行这个命令并滚动（向下箭头）到最后。

git log --abbrev-commit
# commit a07ee27
# Author: Your Name <your@email.address>
Date:   Sun Jul 11 11:47:16 2021 +0200
    Adds hello.txt
(END)
# type ":q" to close

现在运行这个来重置版本库，但保持所有的修改不被缓存。

git reset --soft COMMIT # e.g. a07ee27

与之相反，你也可以进行硬重置，用git reset --hard COMMIT来删除所有修改。还有几种其他的重置方式，你可以从git文档中了解到。

别名

大多数时候，你只需要使用少数几个命令（主要是checkout、add、commit、pull、push和merge），但有些命令可能是你想要“以防万一”的。

存储这些信息的一种方法是git aliases。要配置一个别名，只需在配置中设置它。例如，我经常使用的一个别名是git tree，它以树的形式打印出一个漂亮的历史日志。

git config --global alias.tree 'log --graph --decorate --pretty=oneline --abbrev-commit'
# Try it with `git tree`

另一个有用的别名是删除所有合并的分支。

git config --global alias.clbr '!git branch --merged | grep -v \* | xargs git branch -D'

你可以看到它的前缀是"!"，这允许我们使用任何命令，而不仅仅是git命令。

~完，我是刷碗智，今天礼拜六写的，要准备去刷碗了，骨的白！

▎作者：Valeria 译者：前端小智 来源：dev 原文：https://dev.to/valeriavg/master-git-in-7-minutes-gai

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!