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

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

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

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

5
00:00:18,380 --> 00:00:23,779
Um zu beginnen, gehen Sie zu Ihrem günstigen Speicherort auf Ihrem Computer und

6
00:00:23,779 --> 00:00:27,029
erstellen Sie dann einen Ordner mit dem Namen git-test.

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

8
00:00:37,935 --> 00:00:42,875
Hier habe ich den GIT-TEST-Ordner, den wir gerade in

9
00:00:42,875 --> 00:00:45,390
meinem Visual Studio Code erstellt haben.

10
00:00:45,390 --> 00:00:51,399
Lassen Sie mich eine Datei zu diesem Ordner mit dem Namen index.html hinzufügen,

11
00:00:51,399 --> 00:00:55,869
jetzt können Sie sehen, dass ich in einigen

12
00:00:55,869 --> 00:01:00,504
HTML-Code in diese index.html Datei hinzugefügt habe.

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

14
00:01:02,580 --> 00:01:05,240
Nun wechseln wir zu unserer Befehlszeile,

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 zu einem Git-Repository initialisieren.

17
00:01:15,860 --> 00:01:19,800
Um das in der Befehlszeile zu tun, geben Sie git init ein.

18
00:01:21,620 --> 00:01:26,020
Nun wurde dieser Ordner initialisiert, um ein Git-Repository zu sein.

19
00:01:27,120 --> 00:01:32,650
Das ist also 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 es diesen Ordner als Master markieren.

22
00:01:42,380 --> 00:01:45,690
Das ist der Hauptzweig für mein Kit.

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

24
00:01:48,210 --> 00:01:50,665
wir werden uns in diesem Kurs nicht damit befassen.

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

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 angetippt werden.

34
00:02:28,945 --> 00:02:34,390
Sie sehen, dass es auf dem Zweigmaster steht, also ist das der Master-Zweig, den wir hinzufügen.

35
00:02:34,390 --> 00:02:40,690
Und es sagt, nicht verfolgte Dateien, und zeigt dann index.html in rot.

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

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

38
00:02:49,040 --> 00:02:54,040
Also jetzt, diese index.html Datei, die wir gerade in diesem Ordner erstellt haben,

39
00:02:54,040 --> 00:02:58,100
wurde jetzt nicht zu unserem Git-Repository hinzugefügt.

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

41
00:03:01,680 --> 00:03:07,510
Um das zu tun, sagen wir, git add, und Sie können einfach dot sagen,

42
00:03:07,510 --> 00:03:12,350
was bedeutet, dass alle Dateien im aktuellen Verzeichnis zu dem hinzugefügt werden,

43
00:03:12,350 --> 00:03:17,680
was als Staging-Bereich meines Git-Repositorys bezeichnet wird.

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

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

46
00:03:27,780 --> 00:03:34,202
Und es sagt, dass Änderungen dort festgeschrieben werden und dann den Dateinamen angezeigt werden und dann

47
00:03:34,202 --> 00:03:40,161
bedeutet das, dass diese Datei jetzt bereit ist, in mein Git-Repository übergeben zu werden.

48
00:03:41,647 --> 00:03:46,100
Also, der nächste Befehl, den wir sahen, war git add.

49
00:03:46,100 --> 00:03:51,190
Durch die Verwendung von git add können Sie diesem Staging-Bereich Dateien oder Ordner hinzufügen.

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

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

52
00:04:03,100 --> 00:04:06,460
Das bedeutet also, dass, wenn Sie das Git-Commit

53
00:04:08,130 --> 00:04:12,610
ausführen, dieser Befehl den aktuellen

54
00:04:12,610 --> 00:04:17,250
Status unserer Ordner in unsere Git-Repositories überträgt.

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

56
00:04:20,380 --> 00:04:24,720
sobald sie mit dem git add inszeniert wurden, werden sie in unser

57
00:04:24,720 --> 00:04:29,510
Git-Repository übertragen, wenn wir den git-Befehlsordner ausführen.

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

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

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

61
00:04:45,470 --> 00:04:51,950
Zurück an der Eingabeaufforderung geben wir git commit ein.

62
00:04:51,950 --> 00:04:54,888
Und dann können wir sogar eine Nachricht zu unserem Commit hinzufügen.

63
00:04:54,888 --> 00:05:00,010
Also werde ich git commit -m „first

64
00:05:00,010 --> 00:05:04,160
commit“ sagen, weil dies unser Commit zu unserem Git-Repository ist.

65
00:05:04,160 --> 00:05:10,630
Wenn ich das mache, heißt es, okay, 1 Datei wurde zum Git-Repository hinzugefügt und

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

67
00:05:15,300 --> 00:05:20,790
Also lassen Sie uns jetzt noch einmal überprüfen, git Status und

68
00:05:20,790 --> 00:05:26,220
jetzt sehen Sie, dass es nichts zu begehen sagt, das Arbeitsverzeichnis ist sauber.

69
00:05:26,220 --> 00:05:31,230
Was es bedeutet, ist, dass der aktuelle Status meines Arbeitsverzeichnisses oder meines

70
00:05:31,230 --> 00:05:36,390
Arbeitsordners in das Git-Repository übertragen

71
00:05:36,390 --> 00:05:39,330
wurde, so dass ein Snapshot in mein Git-Repository übertragen wurde.

72
00:05:39,330 --> 00:05:47,200
Jetzt kann ich den nächsten Befehl namens git log —oneline eingeben

73
00:05:47,200 --> 00:05:53,020
und sehen, dass es dort eine Zahl anzeigt, eine achtstellige Zahl,

74
00:05:53,020 --> 00:05:57,850
und dann zeigt es auch die Nachricht, die wir in unser Commit setzen, indem wir zuerst commit sagen.

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

76
00:06:05,120 --> 00:06:08,900
Als wir zurück zu unserem nächsten Git-Befehl gingen,

77
00:06:08,900 --> 00:06:14,094
sahen wir, dass git log —oneline

78
00:06:14,094 --> 00:06:18,540
uns ein kurzes Protokoll aller Commits zeigt.

79
00:06:18,540 --> 00:06:20,080
Wenn Sie einfach git log eingeben,

80
00:06:21,200 --> 00:06:26,220
zeigen Sie viel detailliertere Informationen über alle Commits an.

81
00:06:26,220 --> 00:06:31,344
Aber das reicht aus, um Informationen zu erhalten, die wir benötigen.

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

83
00:06:40,248 --> 00:06:46,141
also werde ich weitere Änderungen an meiner Datei index.html hinzufügen.

84
00:06:54,501 --> 00:06:57,790
Ich habe meine Datei index.html geändert.

85
00:06:57,790 --> 00:07:02,450
Nun, lassen Sie mich einen anderen Ordner unter dem Git-Test-Ordner hinzufügen, also

86
00:07:02,450 --> 00:07:07,990
werde ich hier einen Unterordner namens Vorlagen erstellen, und innerhalb dieses

87
00:07:07,990 --> 00:07:13,450
Vorlagenordners werde ich einen anderen Dateinamen erstellen, test.html.

88
00:07:13,450 --> 00:07:16,230
Dies ist nur, um Ihnen zu zeigen, wie git die

89
00:07:16,230 --> 00:07:21,120
gesamte Ordnerhierarchie in sein Repository übertragen kann.

90
00:07:21,120 --> 00:07:26,002
Also mit test.html jetzt da, werde ich nur

91
00:07:26,002 --> 00:07:31,173
alles von meiner index.html

92
00:07:31,173 --> 00:07:36,499
in meine test.html kopieren und die Änderungen speichern.

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

94
00:07:41,484 --> 00:07:46,480
lassen Sie uns nun den Status unseres Git-Repositorys und dieses Ordners überprüfen.

95
00:07:46,480 --> 00:07:51,740
Geben Sie also Git-Status ein, zeigt an, dass

96
00:07:51,740 --> 00:07:56,020
die Indexstatus-HTML-Datei, die wir bereits früher an das Repository übergeben haben

97
00:07:56,020 --> 00:08:00,570
, jetzt geändert wurde, so dass es eine neuere Version der Datei index.html gibt.

98
00:08:00,570 --> 00:08:03,220
Außerdem zeigt es, dass sich

99
00:08:03,220 --> 00:08:05,530
in diesem Ordner einige nicht verfolgte Dateien befinden, die als Vorlagen bezeichnet werden.

100
00:08:06,620 --> 00:08:11,794
Fügen wir alle diese Änderungen dem Staging

101
00:08:11,794 --> 00:08:16,114
des Bereichs hinzu, geben Sie also erneut git add ein.

102
00:08:16,114 --> 00:08:21,620
Und dann werden alle diese Dateien zum Staging-Bereich hinzugefügt.

103
00:08:21,620 --> 00:08:23,940
Überprüfen Sie den Status erneut.

104
00:08:23,940 --> 00:08:29,490
Sie sehen nun, dass Änderungen, die dem Stagingbereich hinzugefügt wurden.

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

106
00:08:32,850 --> 00:08:36,850
Lassen Sie uns noch ein Commit machen, also

107
00:08:36,850 --> 00:08:42,930
würde ich sagen, git commit -m, zweites Commit und

108
00:08:42,930 --> 00:08:47,096
dann schauen wir uns das Protokoll an.

109
00:08:50,874 --> 00:08:55,246
Wenn Sie das Protokoll auschecken, werden Sie jetzt sehen, dass es zwei Commits

110
00:08:55,246 --> 00:08:58,930
in meinem Git-Repository gibt, das erste und das zweite Commit.

111
00:08:58,930 --> 00:09:03,040
Und beachten Sie, dass jeder von ihnen dort eine andere Nummer erhält.

112
00:09:03,040 --> 00:09:07,130
Wenn Sie ihre vollständigen Details des Protokolls sehen möchten,

113
00:09:07,130 --> 00:09:12,510
können Sie einfach, git log eingeben und dann erhalten Sie mehr Details darin.

114
00:09:12,510 --> 00:09:15,132
Dann, was Sie interessieren würden.

115
00:09:15,132 --> 00:09:20,114
Beachten Sie also, dass das Oneline-Commit nur die

116
00:09:20,114 --> 00:09:24,405
ersten Zeichen meiner Commit-Nummer dort gibt.

117
00:09:24,405 --> 00:09:27,028
Das reicht aus, damit wir operieren können.

118
00:09:29,245 --> 00:09:34,721
Lassen Sie mich nun wieder zu meinem Visual Studio zurückkehren und dann noch eine hinzufügen.

119
00:09:43,885 --> 00:09:47,140
Eine weitere Zeile zu meiner Datei index.html.

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

121
00:09:51,660 --> 00:09:53,170
Und lassen Sie uns die Änderungen speichern. Wenn

122
00:09:55,310 --> 00:09:58,530
Sie zurück zur Befehlszeile gehen,

123
00:09:59,870 --> 00:10:04,490
zeigt der git status an, dass die Datei index.html geändert wurde.

124
00:10:04,490 --> 00:10:10,650
Fügen wir dies dem Stagingbereich hinzu und führen dann ein drittes Commit durch.

125
00:10:10,650 --> 00:10:15,716
Also sagen wir, git add. ,

126
00:10:15,716 --> 00:10:18,720
git status,

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

128
00:10:22,700 --> 00:10:27,722
Jetzt können wir git commit sagen.

129
00:10:31,231 --> 00:10:36,825
„ Third commit“ und tun git log —oneline,

130
00:10:36,825 --> 00:10:43,810
und Sie sehen, dass es drei Commits in unserem Repository gibt.

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

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

133
00:10:51,370 --> 00:10:53,250
am Ende des dritten Commits.

134
00:10:53,250 --> 00:10:56,930
Jetzt können wir auch Änderungen zurücksetzen,

135
00:10:56,930 --> 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 das vorhandene Verzeichnis aus dem alten Commit ersetzen.

138
00:11:09,180 --> 00:11:12,370
Also, mal sehen, wie wir mit diesen Dingen arbeiten können,

139
00:11:12,370 --> 00:11:14,120
indem wir ein paar weitere Befehle lernen.

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

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

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

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

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

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

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

147
00:11:48,050 --> 00:11:51,160
wir zu Ihrer vorherigen Version der Datei zurückkehren möchten,

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

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

150
00:12:00,230 --> 00:12:07,431
Also lasst uns dies nutzen und einige weitere Änderungen an unserem Git-Repository sehen. Wenn wir

151
00:12:09,228 --> 00:12:15,366
zurück zu unserer Befehlszeile gehen, erinnern wir uns, dass

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

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

154
00:12:25,735 --> 00:12:29,885
Also kann ich einfach sagen,

155
00:12:29,885 --> 00:12:34,039
git checkout 900cfcf.

156
00:12:34,039 --> 00:12:41,035
Also, das ist Commit identifizieren Sie die Nummer, die das bestimmte Commit identifiziert,

157
00:12:41,035 --> 00:12:46,971
und dann kann ich index.html sagen, und was Sie bemerken würden, ist,

158
00:12:46,971 --> 00:12:53,662
dass diese ältere Datei jetzt in mein aktuelles Arbeitsverzeichnis ausgecheckt wird. Wenn Sie

159
00:12:55,845 --> 00:12:58,018
zu meinem Visual Studio-Code gehen,

160
00:12:58,018 --> 00:13:03,811
werden Sie jetzt feststellen, dass meine Datei index.html auf die vorherige Arbeit zurückgekehrt ist, so

161
00:13:03,811 --> 00:13:08,580
dass die Änderung, die ich vor dem dritten Commit vorgenommen habe, jetzt verschwunden ist.

162
00:13:08,580 --> 00:13:16,690
Also wurde meine Datei index.html am Ende des zweiten Commits in ihren Zustand wiederhergestellt.

163
00:13:18,920 --> 00:13:23,042
Nun, in der Befehlszeile, wenn ich git status versuche,

164
00:13:23,042 --> 00:13:28,403
werden Sie feststellen, dass diese index.html Datei, die

165
00:13:28,403 --> 00:13:35,470
auf das zurückgesetzt wurde, was sie am Ende des zweiten Commits war, jetzt bereits inszeniert wurde.

166
00:13:35,470 --> 00:13:40,930
Mit diesem Git-Checkout werden wir also eine ältere Version der Datei herausziehen

167
00:13:40,930 --> 00:13:44,390
und dann ersetzen, was sich im aktuellen Verzeichnis befindet, und

168
00:13:44,390 --> 00:13:47,670
dann wird es auch in den Staging-Bereich einchecken.

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

170
00:13:53,400 --> 00:13:56,450
kann ich an diesem Punkt einfach ein anderes Commit machen.

171
00:13:56,450 --> 00:14:02,445
Und dann kann diese Datei als viertes Commit übergeben werden.

172
00:14:02,445 --> 00:14:07,812
Aber wenn ich das nicht mag, möchte ich

173
00:14:07,812 --> 00:14:12,641
am Ende des

174
00:14:12,641 --> 00:14:18,291
dritten Commits zur Datei index.html zurückkehren, dann kann ich nur git reset,

175
00:14:20,339 --> 00:14:25,698
HEAD und index.html sagen.

176
00:14:28,236 --> 00:14:33,356
Was an diesem Punkt passiert, ist, dass die index.html,

177
00:14:33,356 --> 00:14:38,796
die geänderte Version, die ich ausgecheckt hatte, immer noch da ist, aber

178
00:14:38,796 --> 00:14:43,397
diese Datei wurde aus dem Stagingbereich nicht bereitgestellt.

179
00:14:43,397 --> 00:14:49,803
Wenn Sie zurückgehen und sich die index.html in Ihrem Editor ansehen,

180
00:14:49,803 --> 00:14:56,680
wird der Status immer noch am Ende des zweiten Commits angezeigt.

181
00:14:56,680 --> 00:15:01,250
Weil wir die Datei mit der Kasse dafür herausgezogen hatten.

182
00:15:01,250 --> 00:15:06,900
Nun, wenn Sie es wieder auf das zurücksetzen möchten, was es am Ende des dritten Commits war,

183
00:15:06,900 --> 00:15:11,956
dann machen wir noch einen Checkout aus dem dritten Commit, der in unser

184
00:15:11,956 --> 00:15:18,900
Befehlsfenster geht, geben git status ein und

185
00:15:18,900 --> 00:15:23,920
Sie würden feststellen, dass die index.html als modifiziert markiert ist.

186
00:15:23,920 --> 00:15:28,870
Aber es zeigt auch diese besondere Aussage hier.

187
00:15:28,870 --> 00:15:32,270
Es sagt git checkout - und

188
00:15:32,270 --> 00:15:35,310
der Dateiname, um die Änderungen in den Arbeitsverzeichnissen zu verwerfen.

189
00:15:35,310 --> 00:15:39,270
Auf diese Weise können Sie die Änderungen verwerfen, die Sie an einer bestimmten

190
00:15:39,270 --> 00:15:43,095
Datei vorgenommen haben, die dem vorherigen Kommentar entspricht.

191
00:15:43,095 --> 00:15:46,875
Lassen Sie mich einfach diese index.html wieder auf das zurücksetzen, was es am Ende

192
00:15:46,875 --> 00:15:48,205
des dritten Commits war.

193
00:15:48,205 --> 00:15:52,455
Um das zu tun, könnte ich einfach git, checkout,

194
00:15:52,455 --> 00:15:58,540
— index.html sagen und dann,

195
00:15:58,540 --> 00:16:05,480
wenn ich git Status mache, zeigt es, dass mein Verzeichnis sauber ist.

196
00:16:05,480 --> 00:16:08,130
Und im Grunde wurde mein Verzeichnis

197
00:16:08,130 --> 00:16:10,520
am Ende des dritten Commits in den Zustand wiederhergestellt. Wenn ich

198
00:16:12,370 --> 00:16:17,580
zu der Datei in meinem Virtual Studio Code gehe, sehe ich, dass

199
00:16:17,580 --> 00:16:21,060
ihre Datei wieder auf das wiederhergestellt wurde, was sie am Ende der dritten Kappe war.

200
00:16:21,060 --> 00:16:24,740
Dies ist eine Möglichkeit, wie Sie können, wenn Sie

201
00:16:24,740 --> 00:16:27,740
nach dem Commit Änderungen an Ihrer Datei vorgenommen haben und Sie diese Änderungen einfach verwerfen möchten,

202
00:16:27,740 --> 00:16:31,810
können Sie einfach die Datei aus dem letzten Commit auschecken, und dann

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

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

205
00:16:40,960 --> 00:16:44,510
Sie sehr nützlich sind, wenn Sie die Kurse in dieser Spezialisierung durchlaufen,

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

207
00:16:49,160 --> 00:16:56,220
Und wenn Sie vorwärts fortfahren, würden Sie

208
00:16:56,220 --> 00:17:01,790
am Ende der vorherigen Übung immer noch eine geführte Vision des Zustands Ihres Ordners haben.

209
00:17:01,790 --> 00:17:06,180
Wenn Sie also eine neue Übung durchführen und entdeckt haben, dass Sie

210
00:17:06,180 --> 00:17:10,320
Fehler gemacht haben und zum vorherigen Commit zurückkehren möchten,

211
00:17:10,320 --> 00:17:18,000
haben Sie immer eine Möglichkeit, dies mit den Befehlen zu tun, die wir gerade gelassen haben.

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

213
00:17:24,430 --> 00:17:29,260
können Sie mit dem Verständnis und der

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

215
00:17:35,560 --> 00:17:41,685
Jetzt haben wir den Git-Reset für eine bestimmte Datei oder Git-Reset im Allgemeinen überprüft.

216
00:17:41,685 --> 00:17:47,970
Wenn Sie einfach git reset eingeben, werden Sie zum letzten Commit zurückgesetzt.

217
00:17:47,970 --> 00:17:50,680
Es wird also den Stagingbereich auf das letzte Commit zurückgesetzt,

218
00:17:50,680 --> 00:17:55,270
ohne die Änderungen, die Sie an Ihrem Arbeitsverzeichnis vorgenommen haben, zu stören.

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

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

221
00:18:02,140 --> 00:18:07,380
In dieser Woche können Sie Ihren Ordner wieder an den Ort wiederherstellen, an dem Sie sich am

222
00:18:07,380 --> 00:18:10,450
Ausgangspunkt des vorherigen Commits befanden.

223
00:18:10,450 --> 00:18:15,300
Also manchmal, wenn Sie durch eine Übung gehen und Sie erkennen, dass Sie ein Stichwort verpasst.

224
00:18:15,300 --> 00:18:20,174
Haben Sie immer eine Möglichkeit, auf eine vorherige Version zurückzukehren.

225
00:18:20,174 --> 00:18:25,027
Mit diesen Befehlen denke ich, dass Sie alle bereit sind,

226
00:18:25,027 --> 00:18:28,849
git in den Kursen dieser Spezialisierung zu verwenden.

227
00:18:31,070 --> 00:18:34,395
Also, am Ende dieser Übung, hast du es Git?

228
00:18:34,395 --> 00:18:37,459
( MUSIK)