1
00:00:00,000 --> 00:00:04,408
[MUSIK]

2
00:00:04,408 --> 00:00:08,754
Lassen Sie uns nun einige grundlegende Git-Befehle erkunden, die für

3
00:00:08,754 --> 00:00:10,660
uns in dieser Spezialisierung sehr nützlich sind.

4
00:00:11,670 --> 00:00:15,760
Es gibt viel mehr zu bekommen als das, was wir in dieser Übung abdecken.

5
00:00:18,167 --> 00:00:23,407
Um zu beginnen, gehen Sie zu einem geeigneten Speicherort auf Ihrem Computer und

6
00:00:23,407 --> 00:00:26,745
erstellen Sie dann einen Ordner namens git-test.

7
00:00:30,340 --> 00:00:34,600
Öffnen Sie dann diesen Ordner in Ihrem bevorzugten Editor.

8
00:00:38,190 --> 00:00:43,170
Hier habe ich den Git-Test-Ordner, den wir gerade

9
00:00:43,170 --> 00:00:45,390
in meinem Visual Studio-Code erstellt haben.

10
00:00:45,390 --> 00:00:49,257
Lassen Sie mich eine Datei zu diesem

11
00:00:49,257 --> 00:00:54,148
Ordner namens index.html hinzufügen.

12
00:00:54,148 --> 00:00:59,990
Jetzt können Sie sehen, dass ich in einigen HTML-Code in diesen Index zu HTML5 hinzugefügt habe.

13
00:00:59,990 --> 00:01:02,580
Speichern wir die Änderungen.

14
00:01:02,580 --> 00:01:05,240
Jetzt wechseln wir zu unserer Kommandozeile.

15
00:01:06,740 --> 00:01:11,320
Gehen Sie in der Befehlszeile zum Git-Test-Ordner und

16
00:01:11,320 --> 00:01:15,860
lassen Sie uns diesen Ordner als Git-Repository initialisieren. Geben

17
00:01:15,860 --> 00:01:19,800
Sie dazu in der Befehlszeile git init ein.

18
00:01:21,620 --> 00:01:26,020
Nun wurde dieser Ordner als Git-Repository initialisiert.

19
00:01:27,170 --> 00:01:32,650
Dies ist unser erster Git-Befehl, den wir gelernt haben, git init.

20
00:01:32,650 --> 00:01:36,320
Dies initialisiert den aktuellen Ordner als Git-Repository und

21
00:01:36,320 --> 00:01:42,380
wenn es den Ordner initialisiert, wird er diesen Ordner als Master markieren.

22
00:01:42,380 --> 00:01:45,690
Dies ist der Master-Zweig für meinen Git.

23
00:01:45,690 --> 00:01:48,210
Jetzt machen wir uns keine Sorgen über Zweige und so weiter. Damit

24
00:01:48,210 --> 00:01:51,000
werden wir uns in diesem Kurs nicht beschäftigen.

25
00:01:51,000 --> 00:01:56,240
Wir werden nur mit dem Master-Zweig in dieser speziellen Spezialisierung arbeiten.

26
00:01:56,240 --> 00:01:58,500
Dies würde also als Master markiert werden.

27
00:01:58,500 --> 00:02:02,060
Nun ist dies der Anfangspunkt unseres Projektarchivs.

28
00:02:03,770 --> 00:02:08,410
Der nächste Befehl, den wir betrachten werden, ist git status.

29
00:02:08,410 --> 00:02:10,510
Wenn Sie git status in die Befehlszeile eingeben,

30
00:02:10,510 --> 00:02:13,740
wird Ihnen der aktuelle Status des Ordners angezeigt.

31
00:02:13,740 --> 00:02:17,460
Also lassen Sie uns das an der Befehlszeile tun und sehen, was es zeigt.

32
00:02:19,470 --> 00:02:23,395
Geben Sie in der Befehlszeile git status ein und

33
00:02:23,395 --> 00:02:28,945
lesen Sie die Informationen, die im Befehlsfenster nachverfolgt werden.

34
00:02:28,945 --> 00:02:31,235
Sie sehen, dass es auf Zweigmaster steht.

35
00:02:31,235 --> 00:02:35,200
Also, das ist der Master-Zweig, auf dem wir sind, und es sagt,

36
00:02:35,200 --> 00:02:40,690
nicht verfolgte Dateien, und zeigt dann index.html in rot.

37
00:02:40,690 --> 00:02:43,790
Auf Ihrem bestimmten Computer kann es verschiedene Farben verwenden oder

38
00:02:43,790 --> 00:02:49,040
dies anders darstellen, aber das ist, was es auf meinem Mac zeigt.

39
00:02:49,040 --> 00:02:53,775
Nun, diese index.html Datei, die wir gerade in diesem Ordner erstellt haben,

40
00:02:53,775 --> 00:02:58,100
wurde jetzt nicht zu unserem Git-Repository hinzugefügt.

41
00:02:58,100 --> 00:03:01,680
Gehen wir also weiter und fügen Sie diese Datei zum Git-Repository hinzu.

42
00:03:01,680 --> 00:03:06,740
Um das zu tun, sagen wir git add und Sie können einfach

43
00:03:06,740 --> 00:03:12,350
dot sagen, was bedeutet, dass alle Dateien im aktuellen Verzeichnis zu dem,

44
00:03:12,350 --> 00:03:17,680
was der Staging-Bereich meines Git-Projektarchivs genannt wird, hinzugefügt werden.

45
00:03:17,680 --> 00:03:21,740
Also, wenn ich jetzt wieder git status tippe,

46
00:03:21,740 --> 00:03:27,780
werden Sie sehen, dass die Datei index.html grün markiert ist.

47
00:03:27,780 --> 00:03:35,130
Und es sagt, dass Änderungen dort festgeschrieben werden, und zeigt dann den Dateinamen an.

48
00:03:35,130 --> 00:03:39,000
Und dann bedeutet das, dass diese Datei bereit ist, in mein

49
00:03:39,000 --> 00:03:39,830
Git-Repository übergeben zu werden.

50
00:03:41,700 --> 00:03:46,100
Der nächste Befehl, den wir sahen, war git add,

51
00:03:46,100 --> 00:03:51,190
indem Sie git add verwenden, können Sie diesem Staging-Bereich Dateien oder Ordner hinzufügen.

52
00:03:51,190 --> 00:03:57,250
Sobald Sie es dem Staging-Bereich hinzugefügt haben, können Sie diesen Snapshot

53
00:03:57,250 --> 00:04:03,100
unseres Ordnerstatus in unser Git-Repository übertragen.

54
00:04:03,100 --> 00:04:06,460
Das bedeutet also, dass, wenn Sie dieses Git-Commit machen.

55
00:04:08,130 --> 00:04:12,610
Dieser Befehl wird den aktuellen

56
00:04:12,610 --> 00:04:17,200
Status unserer Ordner in unser Git-Repository übertragen.

57
00:04:17,200 --> 00:04:20,380
Also alle Dateien, wie sie im Moment existieren,

58
00:04:20,380 --> 00:04:24,570
sobald sie Stages waren, die das git add verwenden, werden sie in

59
00:04:24,570 --> 00:04:29,510
unser Git-Repository übertragen, wenn wir den Git-Befehls-Ordner ausführen.

60
00:04:29,510 --> 00:04:34,650
Also an diesem Punkt, wenn wir den Befehl git ausführen,

61
00:04:34,650 --> 00:04:40,750
wird unser Anfangszustand jetzt in den ersten Commit zum Git-Repository geändert.

62
00:04:40,750 --> 00:04:42,650
Also lasst uns weitermachen und das tun.

63
00:04:45,470 --> 00:04:49,460
Zurück an der Eingabeaufforderung, geben wir ein,

64
00:04:49,460 --> 00:04:54,880
git commit und dann können wir jemals eine Nachricht zu unserem Commit hinzufügen.

65
00:04:54,880 --> 00:05:00,520
Also werde ich sagen, git commit -m first commit,

66
00:05:00,520 --> 00:05:04,160
weil dies unser erstes Commit zu unserem Git-Repository ist.

67
00:05:04,160 --> 00:05:10,630
Also, wenn ich das tue, sagt es, okay wurde eine Datei zum Git-Repository hinzugefügt und

68
00:05:10,630 --> 00:05:15,300
einige andere Informationen werden in dieses Befehlsfenster eingegeben.

69
00:05:15,300 --> 00:05:20,440
Also lassen Sie uns jetzt noch einmal überprüfen, git Status.

70
00:05:20,440 --> 00:05:26,220
Und jetzt sehen Sie, dass es nichts zum Festschreiben sagt, das Arbeitsverzeichnis ist sauber.

71
00:05:26,220 --> 00:05:31,230
Das bedeutet also, dass der aktuelle Status meines Arbeitsverzeichnisses oder meines

72
00:05:31,230 --> 00:05:35,860
Arbeitsordners an das Git-Repository übergeben wurde.

73
00:05:35,860 --> 00:05:39,330
Also wurde ein Snapshot in mein Git-Repository übertragen.

74
00:05:39,330 --> 00:05:46,851
Jetzt kann ich den nächsten Befehl namens git log —oneline eingeben.

75
00:05:46,851 --> 00:05:53,020
Und sehen Sie, dass es dort eine Zahl zeigt, eine achtstellige Zahl dort.

76
00:05:53,020 --> 00:05:57,850
Und dann zeigt auch die Nachricht, die wir in unserem Commit setzen, indem wir zuerst Commit sagen.

77
00:05:57,850 --> 00:06:03,340
Das ist also das Protokoll aller Commits, die in mein Daten-Repository eingefügt wurden. Als

78
00:06:05,120 --> 00:06:13,832
wir zurück zu unserem nächsten Git-Befehl gingen, sahen wir, dass git log —oneline wir sehen werden und

79
00:06:13,832 --> 00:06:18,540
es zeigt uns ein kurzes Protokoll aller Commits.

80
00:06:18,540 --> 00:06:23,920
Wenn Sie einfach git log eingeben, wird viel mehr Detailinformationen über

81
00:06:23,920 --> 00:06:26,220
alle Commits angezeigt.

82
00:06:26,220 --> 00:06:30,850
Aber das reicht aus, um Informationen zu erhalten, die wir benötigen.

83
00:06:33,350 --> 00:06:40,820
Kommen wir nun zurück zu unserem Editor hier in Visual Studio-Code.

84
00:06:40,820 --> 00:06:44,940
Also werde ich weitere Änderungen an meiner Datei index.html hinzufügen.

85
00:06:44,940 --> 00:06:45,945
Also werde ich hinzufügen.

86
00:06:54,298 --> 00:06:57,790
Also habe ich meine index.html Datei geändert.

87
00:06:57,790 --> 00:07:01,750
Nun lassen Sie mich einen weiteren Ordner unter dem GIT-TEST Ordner hinzufügen.

88
00:07:01,750 --> 00:07:07,220
Also werde ich hier einen Unterordner namens Vorlagen erstellen, und

89
00:07:07,220 --> 00:07:13,450
in diesem Vorlagenordner werde ich eine andere Datei namens test.html erstellen.

90
00:07:13,450 --> 00:07:17,180
Dies ist nur, um Ihnen zu zeigen, wie git die

91
00:07:17,180 --> 00:07:21,120
gesamte Ordnerhierarchie in sein Repository übertragen kann.

92
00:07:21,120 --> 00:07:24,754
Also mit test.html jetzt da,

93
00:07:24,754 --> 00:07:31,185
werde ich nur alles von meiner index.html

94
00:07:31,185 --> 00:07:36,374
in meine test.html kopieren und die Änderungen speichern.

95
00:07:39,447 --> 00:07:41,484
Gehen wir zurück zur Befehlszeile,

96
00:07:41,484 --> 00:07:45,943
lassen Sie uns nun den Status unseres Git-Repositorys und dieses Ordners überprüfen. Die

97
00:07:45,943 --> 00:07:52,880
Eingabe von git status zeigt also, dass die

98
00:07:52,880 --> 00:07:57,370
Datei index.html, die wir bereits früher zum Repository hinzugefügt haben, jetzt geändert wurde.

99
00:07:57,370 --> 00:08:00,207
Also, wenn es eine neue Version der Indexdatei index.html gibt.

100
00:08:00,207 --> 00:08:04,011
Es zeigt auch, dass es einige nicht verfolgte Dateien in

101
00:08:04,011 --> 00:08:06,408
diesem Ordner namens Vorlagen gibt.

102
00:08:06,408 --> 00:08:11,530
Fügen wir alle diese Änderungen unserem Repository hinzu, dem Staging-Bereich.

103
00:08:11,530 --> 00:08:16,640
Geben Sie also wieder git add dot ein und dann

104
00:08:16,640 --> 00:08:21,620
werden alle diese Dateien zum Staging-Bereich hinzugefügt.

105
00:08:21,620 --> 00:08:23,940
Auch wenn Sie den Status auschecken,

106
00:08:23,940 --> 00:08:29,490
sehen Sie jetzt, dass die Änderungen, die ich dem Stagingbereich hinzugefügt wurde.

107
00:08:29,490 --> 00:08:32,850
Alle diese Dateien wurden also dem Staging-Bereich hinzugefügt.

108
00:08:32,850 --> 00:08:34,560
Lass uns noch ein Commit machen.

109
00:08:34,560 --> 00:08:38,381
Also würde ich sagen git commit -m.

110
00:08:40,218 --> 00:08:47,234
Zweites Commit und dann lassen Sie uns das Protokoll überprüfen.

111
00:08:50,828 --> 00:08:57,480
Wenn Sie das Protokoll auschecken, sehen Sie jetzt, dass es zwei Commits in meinem Git-Repository gibt.

112
00:08:57,480 --> 00:08:59,130
Der erste und der zweite Commit und

113
00:08:59,130 --> 00:09:03,040
beachten Sie, dass jeder von ihnen dort eine andere Zahl erhält.

114
00:09:03,040 --> 00:09:09,830
Wenn Sie die vollständigen Details des Protokolls sehen möchten, können Sie einfach git log eingeben und

115
00:09:09,830 --> 00:09:15,095
dann sehen Sie mehr Details darin, was Sie interessieren würden.

116
00:09:15,095 --> 00:09:19,115
Beachten Sie also, dass der Oneline-Commit

117
00:09:19,115 --> 00:09:24,405
nur die ersten Zeichen meiner Commit-Nummer gibt.

118
00:09:24,405 --> 00:09:26,395
Das reicht aus, damit wir operieren können.

119
00:09:29,245 --> 00:09:35,502
Lassen Sie mich jetzt wieder zu meinem Visual Studio gehen und noch eine hinzufügen.

120
00:09:44,019 --> 00:09:45,890
Eine weitere Zeile zu meiner Datei index.html.

121
00:09:47,140 --> 00:09:49,800
Jetzt wurde meine Datei index.html geändert.

122
00:09:51,660 --> 00:09:53,123
Und lassen Sie uns die Änderungen speichern.

123
00:09:55,099 --> 00:09:57,871
Gehen Sie zurück zur Befehlszeile,

124
00:09:57,871 --> 00:10:04,304
gehen Sie in git status zeigt, dass die Datei index.html geändert wurde.

125
00:10:04,304 --> 00:10:10,650
Fügen wir dies dem Staging-Bereich hinzu und führen Sie dann ein drittes Commit aus.

126
00:10:10,650 --> 00:10:18,720
Also sagen wir, git add dot git status.

127
00:10:18,720 --> 00:10:22,487
Jetzt sehen Sie, dass die index.html, die geänderte Version hinzugefügt wurde.

128
00:10:22,487 --> 00:10:26,240
Jetzt können wir git commit sagen.

129
00:10:31,176 --> 00:10:37,084
Drittes Commit.

130
00:10:37,084 --> 00:10:43,810
Und git log oneline, und Sie werden sehen, dass es drei Commits in unserem Repository gibt.

131
00:10:43,810 --> 00:10:48,220
Jetzt enthält unser Repository Snapshots von drei verschiedenen Typen.

132
00:10:48,220 --> 00:10:51,468
Am Ende des ersten Commits, am Ende des zweiten Commits und

133
00:10:51,468 --> 00:10:52,985
am Ende des dritten Commits.

134
00:10:52,985 --> 00:10:56,842
Jetzt können wir auch Änderungen zurücksetzen.

135
00:10:56,842 --> 00:11:01,590
Wir können das Repository auf eine vorherige Version zurücksetzen.

136
00:11:01,590 --> 00:11:04,780
Wir können eine Datei aus einem älteren Commit herausziehen und

137
00:11:04,780 --> 00:11:09,180
dann diese vorhandene Datei in unserer direkt aus dem älteren Commit ripple.

138
00:11:09,180 --> 00:11:14,120
Mal sehen, wie wir mit diesen Dingen arbeiten können, indem wir ein paar weitere Befehle lernen.

139
00:11:15,820 --> 00:11:21,450
In diesem Stadium befindet sich unsere Datei index.HTML im aktuellen Zustand.

140
00:11:21,450 --> 00:11:24,795
So können Sie feststellen, dass es ein h1 und zwei p hat.

141
00:11:26,530 --> 00:11:29,365
Schauen wir uns nun den nächsten Git-Befehl an.

142
00:11:30,815 --> 00:11:36,185
Der nächste Git-Befehl, über den wir lernen werden, ist git checkout.

143
00:11:36,185 --> 00:11:40,300
Dieser Checkout-Befehl ermöglicht es uns, eine Datei

144
00:11:40,300 --> 00:11:44,040
aus einem früheren Commit in unserem Git-Repository auszuchecken.

145
00:11:44,040 --> 00:11:48,050
Wenn wir also die aktuelle Datei, die wir in unserem Ordner haben, nicht mögen und

146
00:11:48,050 --> 00:11:51,160
wir zu einer früheren Version der Datei zurückkehren möchten,

147
00:11:51,160 --> 00:11:55,090
können wir die Datei immer aus einem vorherigen Commit oder

148
00:11:55,090 --> 00:12:00,230
aus dem aktuellen Commit auschecken und dann weiter mit dieser Datei arbeiten.

149
00:12:00,230 --> 00:12:07,136
Also lasst uns dies nutzen und einige Ordneränderungen in unserem Git-Repository sehen. Wenn wir

150
00:12:09,137 --> 00:12:15,346
zurück zu unserer Befehlszeile gehen, erinnern wir uns, dass

151
00:12:15,346 --> 00:12:20,235
ich zwischen dem zweiten und dem dritten Commit Änderungen an meiner Datei index.html vorgenommen habe.

152
00:12:20,235 --> 00:12:25,526
Angenommen, ich möchte von meinem zweiten Commit zur Datei index.html zurückkehren.

153
00:12:25,526 --> 00:12:33,951
Also kann ich einfach sagen git checkout 900cfcf.

154
00:12:33,951 --> 00:12:40,980
Das ist also Commit-Bezeichner, die Nummer, die diesen bestimmten Kommentar identifiziert.

155
00:12:40,980 --> 00:12:46,170
Und dann kann ich sagen, index.html und was Sie bemerken würden,

156
00:12:46,170 --> 00:12:53,430
ist, dass die ältere Datei jetzt in mein aktuelles Arbeitsverzeichnis eingecheckt wird. Wenn Sie

157
00:12:55,919 --> 00:12:58,043
zu meinem Visual Studio-Code gehen, stellen

158
00:12:58,043 --> 00:13:03,340
Sie jetzt fest, dass meine Datei index.html auf die vorherige Version zurückgesetzt wurde.

159
00:13:03,340 --> 00:13:07,936
Also ist die Änderung, die vor dem dritten Commit vorgenommen wurde, jetzt verschwunden.

160
00:13:07,936 --> 00:13:13,123
Also wurde meine Datei index.html in

161
00:13:13,123 --> 00:13:18,750
einem Zustand am Ende des zweiten Kommentars wiederhergestellt.

162
00:13:18,750 --> 00:13:24,863
Jetzt in der Befehlszeile, wenn ich git status tippe.

163
00:13:24,863 --> 00:13:29,140
Sie werden wie diese index.html Datei bemerken. Was auf

164
00:13:29,140 --> 00:13:33,520
das zurückgekehrt ist, was es am Ende des zweiten Commits war.

165
00:13:33,520 --> 00:13:37,710
Es wurde jetzt bereits inszeniert, so dass

166
00:13:38,720 --> 00:13:42,930
wir mit dem git checkout eine ältere Version der Datei herausziehen und dann ersetzen, was

167
00:13:42,930 --> 00:13:47,670
sich im aktuellen Verzeichnis befindet, und dann wird es auch in den Staging-Bereich einchecken.

168
00:13:48,970 --> 00:13:53,960
Also, wenn ich das tue und dann merke ich, dass das ist, was ich will, kann ich

169
00:13:53,960 --> 00:13:56,450
an diesem Punkt einfach ein anderes Commit machen.

170
00:13:56,450 --> 00:14:01,090
Und dann kann diese Datei als viertes Commit kommentiert werden.

171
00:14:02,710 --> 00:14:08,035
Aber wenn ich das nicht mag, möchte ich

172
00:14:08,035 --> 00:14:13,700
am Ende des dritten Commits zu dieser Datei index.html zurückkehren.

173
00:14:13,700 --> 00:14:21,788
Dann kann ich nur sagen, git reset HEAD und

174
00:14:21,788 --> 00:14:27,404
index.html.

175
00:14:27,404 --> 00:14:31,821
An diesem Punkt passiert also, dass die index.html, die

176
00:14:31,821 --> 00:14:36,780
modifizierte Version, die ich auschecke, immer noch da ist.

177
00:14:36,780 --> 00:14:41,275
Diese Datei wurde jedoch aus dem Stagingbereich nicht bereitgestellt.

178
00:14:43,650 --> 00:14:49,269
Wenn Sie zurückgehen und sich die index.html in Ihrem Editor ansehen,

179
00:14:49,269 --> 00:14:54,887
wird es immer noch die Phase am Ende des zweiten Commits anzeigen,

180
00:14:54,887 --> 00:15:01,250
da wir diese Datei mit Auschecken dafür herausgezogen hatten.

181
00:15:01,250 --> 00:15:06,072
Nun, wenn Sie es wieder auf das zurücksetzen wollen, was es am Ende des dritten Commits war,

182
00:15:06,072 --> 00:15:09,490
dann machen wir noch einen Check-out aus dem dritten Commit. Wenn

183
00:15:10,540 --> 00:15:18,900
Sie in unser Befehlsfenster gehen, geben

184
00:15:18,900 --> 00:15:24,580
Sie git status ein und Sie würden feststellen, dass die index.html als modifiziert markiert ist, aber

185
00:15:24,580 --> 00:15:31,040
es zeigt auch diese spezielle Anweisung hier, es sagt git checkout -

186
00:15:31,040 --> 00:15:35,270
und der Dateilink, um die Änderungen im Arbeitsverzeichnis zu verwerfen.

187
00:15:35,270 --> 00:15:38,150
So können Sie die Änderungen, die Sie

188
00:15:38,150 --> 00:15:43,095
nicht benötigen, an einer bestimmten Datei verwerfen, die dem vorherigen Commit entspricht.

189
00:15:43,095 --> 00:15:45,595
Lassen Sie mich also diese index.html wieder

190
00:15:45,595 --> 00:15:48,205
auf das wiederherstellen, was es am Ende des dritten Commits war.

191
00:15:48,205 --> 00:15:53,104
Also, um das zu tun, werde ich einfach git

192
00:15:53,104 --> 00:15:57,647
checkout - index.html sagen.

193
00:15:57,647 --> 00:16:04,278
Und dann, wenn ich git Status mache, zeigt es, dass mein Verzeichnis sauber ist und im Grunde

194
00:16:04,278 --> 00:16:10,520
mein Verzeichnis in den Zustand des Endes des dritten Commits wiederhergestellt wurde. Wenn ich

195
00:16:12,370 --> 00:16:17,580
zur Datei in meinem Visual Studio-Code gehe, sehe ich, dass

196
00:16:17,580 --> 00:16:21,060
die Datei wieder auf das wiederhergestellt wurde, was sie am Ende des dritten Commits war.

197
00:16:21,060 --> 00:16:25,840
Dies ist eine Möglichkeit, wie Sie können, wenn Sie nach dem Commit Änderungen an einer Datei vorgenommen haben und

198
00:16:25,840 --> 00:16:28,700
Sie diese Änderungen einfach verwerfen möchten, können Sie

199
00:16:28,700 --> 00:16:30,880
die Datei einfach aus dem letzten Commit auschecken.

200
00:16:30,880 --> 00:16:34,530
Und dann

201
00:16:34,530 --> 00:16:36,220
werden alle Ihre Änderungen, die Sie nach dem letzten Commit vorgenommen haben, vor Ort verworfen.

202
00:16:36,220 --> 00:16:40,960
Dies sind also einige grundlegende Befehle, die sehr nützlich für

203
00:16:40,960 --> 00:16:44,510
Sie sind, wenn Sie zu den Kursen in dieser Spezialisierung gehen,

204
00:16:44,510 --> 00:16:49,160
weil Sie am Ende jeder Übung verpflichten möchten.

205
00:16:49,160 --> 00:16:56,220
Und wenn Sie fortfahren, haben Sie

206
00:16:56,220 --> 00:17:01,790
am Ende der vorherigen Übung immer noch eine festgeschriebene Version des Ordnerstatus.

207
00:17:01,790 --> 00:17:06,920
Wenn Sie also eine neue Übung ausführen und feststellen, dass Sie

208
00:17:06,920 --> 00:17:11,803
Fehler gemacht haben und zum vorherigen Commit zurückkehren möchten,

209
00:17:11,803 --> 00:17:18,010
haben Sie immer eine Möglichkeit, dies mit den Befehlen zu tun, die wir gerade gelernt haben.

210
00:17:18,010 --> 00:17:24,430
Mit diesem grundlegenden Verständnis dieser wenigen Git-Befehle

211
00:17:24,430 --> 00:17:29,260
werden wir in der Lage sein, mit dem Verständnis und der

212
00:17:29,260 --> 00:17:33,570
Verwendung von git in den Kursen dieser Spezialisierung fortzufahren.

213
00:17:35,560 --> 00:17:41,260
Also, jetzt haben wir den git reset für eine bestimmte Datei oder git reset

214
00:17:41,260 --> 00:17:47,970
im Allgemeinen überprüft, wenn Sie einfach git reset eingeben, wird es Sie wieder zum letzten Commit zurücksetzen.

215
00:17:47,970 --> 00:17:51,360
Es würde also den Stagingbereich auf das letzte Commit zurücksetzen,

216
00:17:51,360 --> 00:17:55,270
ohne die Änderungen zu stören, die Sie an Ihrem Arbeitsverzeichnis vorgenommen haben.

217
00:17:55,270 --> 00:17:58,390
Wenn Sie also zurücksetzen, können Sie

218
00:17:58,390 --> 00:18:02,140
die vorherige Version der Datei auschecken, die Sie im vorherigen Commit übernommen haben.

219
00:18:02,140 --> 00:18:07,380
Auf diese Weise können Sie Ihren Ordner wieder an der Stelle wiederherstellen, an

220
00:18:07,380 --> 00:18:10,450
der Sie sich am Ausgangspunkt des vorherigen Commits befanden.

221
00:18:10,450 --> 00:18:15,010
Also manchmal, wenn Sie eine Übung machen und Sie erkennen, dass

222
00:18:15,010 --> 00:18:20,360
Sie Fehler gemacht haben, haben Sie immer eine Möglichkeit, zurück zu einer früheren Version.

223
00:18:20,360 --> 00:18:25,665
Also mit diesen Befehlen denke ich, dass Sie alle bereit sind, git in

224
00:18:25,665 --> 00:18:31,111
den Kursen dieser Spezialisierung zu verwenden Also

225
00:18:31,111 --> 00:18:34,276
am Ende dieser Übung, hast du es Git?

226
00:18:34,276 --> 00:18:37,459
( MUSIK)