1
00:00:00,000 --> 00:00:04,425
[МУЗЫКА]

2
00:00:04,425 --> 00:00:09,324
Давайте теперь рассмотрим некоторые основные команды Git, которые очень полезны для

3
00:00:09,324 --> 00:00:11,474
нас в этой специализации.

4
00:00:11,474 --> 00:00:15,055
Git гораздо больше, чем то, что мы освещаем в этом упражнении.

5
00:00:18,130 --> 00:00:23,231
Чтобы начать работу, перейдите в удобное расположение на компьютере,

6
00:00:23,231 --> 00:00:26,523
а затем создайте папку с именем git-test.

7
00:00:30,140 --> 00:00:34,408
Затем откройте эту папку в своем любимом редакторе.

8
00:00:37,895 --> 00:00:42,585
Здесь у меня есть папка git-test, которую мы только что

9
00:00:42,585 --> 00:00:45,390
создали в моем Visual Studio Code.

10
00:00:45,390 --> 00:00:51,915
Позвольте мне добавить файл в эту папку с именем index.html.

11
00:00:54,122 --> 00:01:00,430
Теперь вы можете видеть, что я добавил некоторый HTML-код в этот файл index.html.

12
00:01:00,430 --> 00:01:06,507
Давайте сохраним изменения, теперь переключимся на нашу командную строку.

13
00:01:06,507 --> 00:01:10,903
В командной строке перейдите в папку git-test, и

14
00:01:10,903 --> 00:01:15,860
давайте инициализируем эту папку, чтобы быть репозиторием Git.

15
00:01:15,860 --> 00:01:19,800
Поэтому, чтобы сделать это, добавьте командную строку, введите, git init.

16
00:01:21,620 --> 00:01:27,710
Теперь эта папка была инициализирована как репозиторий Git, так что

17
00:01:27,710 --> 00:01:32,650
это наша первая команда Git, которую мы узнали, git init.

18
00:01:32,650 --> 00:01:36,320
Это инициализирует текущую папку как репозиторий Git, и

19
00:01:36,320 --> 00:01:42,380
когда он инициализирует папку, он помечает эту папку как мастер.

20
00:01:42,380 --> 00:01:47,770
Это главная ветка для моего Git, теперь давайте не будем беспокоиться о ветках и

21
00:01:47,770 --> 00:01:51,000
так далее, мы не будем иметь дело с этим в этом курсе.

22
00:01:51,000 --> 00:01:55,738
Мы будем работать только с главной веткой в этой конкретной специализации,

23
00:01:55,738 --> 00:01:58,500
так что это будет отмечено как мастер.

24
00:01:58,500 --> 00:02:02,060
Теперь это начальная точка нашего репозитория,

25
00:02:03,770 --> 00:02:08,410
следующая команда, которую мы собираемся посмотреть, - это статус git.

26
00:02:08,410 --> 00:02:12,600
Если вы введете git status в командной строке, он сообщит вам текущий статус

27
00:02:12,600 --> 00:02:17,460
папки, поэтому давайте сделаем это в командной строке и посмотрим, что он показывает.

28
00:02:19,470 --> 00:02:23,395
В командной строке введите git status и

29
00:02:23,395 --> 00:02:28,945
прочитайте информацию, введенную в командной строке.

30
00:02:28,945 --> 00:02:33,943
Вы видите, что он говорит: «На ветке мастер», так что это главная ветка, на которой мы находимся,

31
00:02:33,943 --> 00:02:40,690
и он говорит, что неотслеживаемые файлы, а затем показывает index.html красным.

32
00:02:40,690 --> 00:02:44,458
На конкретном компьютере он может использовать разные цвета или

33
00:02:44,458 --> 00:02:49,040
представлять это по-разному, но это то, что он показывает на моем Mac.

34
00:02:49,040 --> 00:02:54,040
Итак, теперь этот файл index.html, который мы только что создали в этой папке,

35
00:02:54,040 --> 00:02:58,140
теперь не был добавлен в наш репозиторий Git.

36
00:02:58,140 --> 00:03:01,335
Итак, давайте продолжим и добавим этот файл в репозиторий Git.

37
00:03:01,335 --> 00:03:07,510
Поэтому, чтобы сделать это, мы говорим, git add, и вы можете просто сказать точку,

38
00:03:07,510 --> 00:03:12,350
что означает, что все файлы в текущем каталоге будут добавлены к

39
00:03:12,350 --> 00:03:17,680
тому, что называется промежуточной областью моего репозитория Git.

40
00:03:17,680 --> 00:03:22,880
Итак, теперь, если я снова напечатаю статус git, вы увидите,

41
00:03:22,880 --> 00:03:27,910
что файл index.html помечен зеленым цветом, и

42
00:03:27,910 --> 00:03:35,130
он говорит, что изменения должны быть зафиксированы там, а затем показывает имя файла.

43
00:03:35,130 --> 00:03:35,672
И затем,

44
00:03:35,672 --> 00:03:39,601
так что это означает, что этот файл теперь готов для фиксации в моем репозитории Git.

45
00:03:41,438 --> 00:03:46,856
Таким образом, следующая команда, которую мы видели, была git add, используя git add,

46
00:03:46,856 --> 00:03:51,190
вы можете добавить файл или папки в промежуточную область.

47
00:03:51,190 --> 00:03:57,250
Поэтому, как только вы добавите его в промежуточную область, вы можете зафиксировать этот снимок

48
00:03:57,250 --> 00:04:03,100
состояния нашей папки в наш репозиторий Git.

49
00:04:03,100 --> 00:04:06,460
Таким образом, это означает, что когда вы делаете git commit,

50
00:04:08,130 --> 00:04:12,610
то, что эта команда будет делать, это зафиксировать

51
00:04:12,610 --> 00:04:17,200
текущее состояние наших папок в нашем репозитории Git.

52
00:04:17,200 --> 00:04:21,780
Таким образом, все файлы, как они существуют на данный момент, как только они были поставлены

53
00:04:21,780 --> 00:04:25,560
с помощью git add, то они будут зафиксированы через репозиторий Git,

54
00:04:25,560 --> 00:04:29,510
затем мы выполняем папку команд git.

55
00:04:29,510 --> 00:04:33,580
Итак, на данный момент, когда мы выполняем команду git,

56
00:04:33,580 --> 00:04:38,373
наше первоначальное состояние теперь будет изменено на первую фиксацию

57
00:04:38,373 --> 00:04:42,369
в репозитории Git, так что давайте продолжим и сделаем это.

58
00:04:45,208 --> 00:04:50,261
Вернитесь в командную строку, давайте напечатаем git commit,

59
00:04:50,261 --> 00:04:54,880
а затем мы можем даже добавить сообщение к нашей фиксации.

60
00:04:54,880 --> 00:04:59,275
Поэтому я собираюсь сказать git commit -m «first commit»,

61
00:04:59,275 --> 00:05:03,879
потому что это наша первая фиксация в нашем репозитории Git.

62
00:05:03,879 --> 00:05:10,106
Поэтому, когда я это делаю, он говорит: хорошо, один файл был добавлен в репозиторий Git, и

63
00:05:10,106 --> 00:05:15,300
некоторая другая информация будет введена в окно команд.

64
00:05:15,300 --> 00:05:20,440
Итак, давайте теперь проверим, снова, git статус,

65
00:05:20,440 --> 00:05:26,220
и теперь вы видите, что он говорит, что ничего не делать, рабочий каталог чист.

66
00:05:26,220 --> 00:05:31,230
Так что это означает, что текущее состояние моего рабочего каталога или

67
00:05:31,230 --> 00:05:35,860
рабочей папки было зафиксировано в репозитории Git.

68
00:05:35,860 --> 00:05:41,050
Таким образом, моментальный снимок был зафиксирован в моем репозитории Git, теперь я могу ввести следующую

69
00:05:41,050 --> 00:05:47,200
команду, называемую git log —oneline.

70
00:05:47,200 --> 00:05:52,156
И посмотрите, что он показывает там число, восьмизначное число там, а

71
00:05:52,156 --> 00:05:57,545
также показывает сообщение, которое мы помещаем в нашу фиксацию, говорящее «first commit».

72
00:05:57,545 --> 00:06:03,340
Так что это журнал всех коммитов, которые были помещены в мой репозиторий Git.

73
00:06:05,120 --> 00:06:08,900
Итак, возвращаясь к нашей следующей команде git,

74
00:06:08,900 --> 00:06:14,094
мы увидели, что git log - oneline

75
00:06:14,094 --> 00:06:18,540
покажет нам краткий журнал всех коммитов.

76
00:06:18,540 --> 00:06:20,442
Если вы просто введете git log,

77
00:06:20,442 --> 00:06:25,658
он будет отображать гораздо более подробную информацию обо всех коммитах, но

78
00:06:25,658 --> 00:06:30,652
этого достаточно для получения информации, которую мы требуем.

79
00:06:33,013 --> 00:06:40,820
Давайте вернемся к нашему редактору здесь, в Visual Studio Code.

80
00:06:40,820 --> 00:06:45,379
Поэтому я собираюсь добавить больше изменений в мой файл index.html, поэтому я добавлю,

81
00:06:54,307 --> 00:06:57,790
поэтому я изменил свой файл index.html.

82
00:06:57,790 --> 00:07:02,453
Теперь позвольте мне добавить еще одну папку в папку git-test, поэтому

83
00:07:02,453 --> 00:07:06,890
я создам подпапку здесь с именами шаблонов.

84
00:07:06,890 --> 00:07:09,344
И внутри этой папки шаблонов

85
00:07:09,344 --> 00:07:13,039
я собираюсь создать другой файл с именем test.html.

86
00:07:13,039 --> 00:07:17,798
Это просто, чтобы показать вам, как Git может фиксировать всю

87
00:07:17,798 --> 00:07:21,120
иерархию папок в своем репозитории.

88
00:07:21,120 --> 00:07:24,734
Итак, с test.html теперь,

89
00:07:24,734 --> 00:07:29,321
я просто собираюсь скопировать все из

90
00:07:29,321 --> 00:07:34,047
моего index.html в мой test.html и

91
00:07:34,047 --> 00:07:41,422
сохранить изменения Возвращаясь к командной строке,

92
00:07:41,422 --> 00:07:46,187
давайте теперь проверить статус нашего репозитория Git и этой папки.

93
00:07:46,187 --> 00:07:51,079
Таким образом, ввод статуса git показывает, что файл index.html, который мы

94
00:07:51,079 --> 00:07:55,971
уже добавили ранее в репозиторий, теперь был изменен,

95
00:07:55,971 --> 00:08:00,570
поэтому есть более новая версия файла index.html.

96
00:08:00,570 --> 00:08:03,220
Кроме того, он показывает, что

97
00:08:03,220 --> 00:08:05,530
в этой папке есть некоторые неотслеживаемые файлы, называемые шаблонами.

98
00:08:06,620 --> 00:08:11,720
Давайте добавим все эти изменения в наш репозиторий, в промежуточную область.

99
00:08:11,720 --> 00:08:16,350
Итак, снова введите git add., а

100
00:08:16,350 --> 00:08:21,620
затем все эти файлы будут добавлены в промежуточную область.

101
00:08:21,620 --> 00:08:27,820
Опять же, проверяя статус, теперь вы увидите, что изменения, которые были

102
00:08:27,820 --> 00:08:32,850
добавлены в промежуточную область, поэтому все эти файлы были добавлены в промежуточную область.

103
00:08:32,850 --> 00:08:37,735
Давайте сделаем еще одну фиксацию, поэтому я бы сказал git commit -m,

104
00:08:41,526 --> 00:08:46,595
«Second commit», а затем, давайте проверим журнал.

105
00:08:50,794 --> 00:08:54,179
Если вы проверите журнал, теперь вы увидите, что

106
00:08:54,179 --> 00:08:58,930
в моем репозитории Git есть две фиксации, первая и вторая фиксация.

107
00:08:58,930 --> 00:09:02,826
И обратите внимание, что каждому из них дается разное число.

108
00:09:02,826 --> 00:09:09,700
Если вы хотите увидеть полную информацию о журнале, вы можете просто ввести git log.

109
00:09:09,700 --> 00:09:12,510
И тогда вы увидите там больше деталей,

110
00:09:12,510 --> 00:09:15,095
чем то, что вас интересует.

111
00:09:15,095 --> 00:09:19,115
Поэтому обратите внимание, что одна строка

112
00:09:19,115 --> 00:09:24,405
фиксации дает только первые несколько символов моего номера фиксации там.

113
00:09:24,405 --> 00:09:26,674
Этого достаточно для того, чтобы мы могли работать.

114
00:09:29,000 --> 00:09:34,006
Позвольте мне теперь вернуться к моей Visual Studio и добавить еще одну,

115
00:09:43,821 --> 00:09:45,890
еще одну строку в мой файл index.html.

116
00:09:47,140 --> 00:09:52,666
Итак, теперь мой файл index.html был изменен, и давайте сохраним изменения.

117
00:09:55,066 --> 00:09:57,813
Возвращаясь к командной строке,

118
00:09:57,813 --> 00:10:04,490
выполнение статуса git показывает, что файл index.html был изменен.

119
00:10:04,490 --> 00:10:08,640
Итак, давайте добавим это в промежуточную область, а

120
00:10:08,640 --> 00:10:14,382
затем сделаем третью фиксацию, так что скажем git add. ,

121
00:10:14,382 --> 00:10:18,720
статус git.

122
00:10:18,720 --> 00:10:22,700
Теперь вы увидите, что index.html, измененная версия, была добавлена.

123
00:10:22,700 --> 00:10:27,305
Теперь мы можем сказать git commit,

124
00:10:31,164 --> 00:10:37,144
«Third commit», и сделать git log —oneline,

125
00:10:37,144 --> 00:10:43,818
и вы увидите, что в нашем репозитории есть три коммита.

126
00:10:43,818 --> 00:10:47,625
Итак, теперь наш репозиторий содержит снимки трех разных точек,

127
00:10:47,625 --> 00:10:51,234
в конце первой фиксации, в конце второй фиксации и

128
00:10:51,234 --> 00:10:52,929
в конце третьей фиксации.

129
00:10:52,929 --> 00:10:56,297
Теперь мы также можем откатить изменения,

130
00:10:56,297 --> 00:11:01,417
мы можем вернуть репозиторий к предыдущей версии.

131
00:11:01,417 --> 00:11:04,366
Мы можем вытащить файл из старого коммита, а

132
00:11:04,366 --> 00:11:09,180
затем заменить существующий файл в нашем каталоге из старого коммита.

133
00:11:09,180 --> 00:11:13,604
Итак, давайте посмотрим, как мы можем работать с этими вещами

134
00:11:13,604 --> 00:11:15,608
, изучив еще пару команд.

135
00:11:15,608 --> 00:11:21,759
На этом этапе наш файл index.html находится в текущем состоянии,

136
00:11:21,759 --> 00:11:26,530
поэтому вы можете заметить, что он имеет h1 и два p.

137
00:11:26,530 --> 00:11:29,365
Давайте теперь посмотрим на следующую команду Git.

138
00:11:30,815 --> 00:11:36,185
Следующая команда Git, о которой мы собираемся узнать, - это проверка git.

139
00:11:36,185 --> 00:11:40,300
Таким образом, эта команда checkout позволяет нам проверить файл

140
00:11:40,300 --> 00:11:44,040
из предыдущей фиксации в нашем репозитории Git.

141
00:11:44,040 --> 00:11:47,709
Поэтому, если нам не нравится текущий файл, который у нас есть в нашей папке,

142
00:11:47,709 --> 00:11:50,907
и мы хотим вернуться к предыдущей версии файла.

143
00:11:50,907 --> 00:11:54,782
Мы всегда можем проверить файл из предыдущей фиксации или

144
00:11:54,782 --> 00:12:00,230
из текущей фиксации, а затем продолжить работу с этим файлом.

145
00:12:00,230 --> 00:12:07,190
Итак, давайте воспользуемся этим и посмотрим некоторые дальнейшие изменения в нашем репозитории Git.

146
00:12:09,350 --> 00:12:14,705
Возвращаясь к нашей командной строке, мы помним, что

147
00:12:14,705 --> 00:12:20,235
между вторым и третьим фиксацией я внес изменения в свой файл index.html.

148
00:12:20,235 --> 00:12:25,477
Предположим, я хочу вернуться к файлу index.html из моей второй фиксации.

149
00:12:25,477 --> 00:12:31,244
Поэтому я могу просто сказать, git checkout 900cfcf,

150
00:12:31,244 --> 00:12:35,045
так что это идентификатор фиксации,

151
00:12:35,045 --> 00:12:40,980
число, которое идентифицирует эту конкретную фиксацию.

152
00:12:40,980 --> 00:12:46,117
И тогда я могу сказать index.html, и вы заметили бы

153
00:12:46,117 --> 00:12:53,190
, что весь файл теперь будет выписан в мой текущий рабочий каталог.

154
00:12:55,721 --> 00:12:57,901
Перейдя к моему коду Visual Studio,

155
00:12:57,901 --> 00:13:03,340
вы теперь заметите, что мой файл index.html вернулся к предыдущей версии.

156
00:13:03,340 --> 00:13:07,928
Таким образом, изменение, которое я сделал до третьей фиксации, теперь исчезло.

157
00:13:07,928 --> 00:13:16,482
Таким образом, мой файл index.html был восстановлен в своем состоянии в конце второй фиксации.

158
00:13:18,607 --> 00:13:22,936
Теперь в командной строке, если я введу статус git,

159
00:13:22,936 --> 00:13:26,711
вы заметите, что этот файл index.html,

160
00:13:26,711 --> 00:13:33,520
который вернулся к тому, что он был в конце второй фиксации.

161
00:13:33,520 --> 00:13:37,710
Теперь он уже был поставлен, поэтому использование этой git

162
00:13:38,720 --> 00:13:43,670
checkout вытащит старую версию файла, а затем заменит то, что находится в текущем

163
00:13:43,670 --> 00:13:48,400
каталоге, а затем он также проверит его в промежуточную область.

164
00:13:48,400 --> 00:13:53,400
Итак, теперь, если я это сделаю, а затем я понимаю, что это то, что я хочу,

165
00:13:53,400 --> 00:13:56,450
я могу просто сделать еще одну фиксацию на данном этапе.

166
00:13:56,450 --> 00:14:02,249
И тогда этот файл может быть зафиксирован как четвертая фиксация,

167
00:14:02,249 --> 00:14:05,200
но предположим, мне это не нравится.

168
00:14:05,200 --> 00:14:10,553
Я хочу вернуться к файлу index.html в

169
00:14:10,553 --> 00:14:17,704
конце третьей фиксации, тогда все, что я могу сделать, это сказать git reset,

170
00:14:20,178 --> 00:14:24,866
HEAD и index.html.

171
00:14:28,084 --> 00:14:32,404
Итак, на данный момент происходит то, что index.html,

172
00:14:32,404 --> 00:14:37,264
измененная версия, которую я проверил, все еще существует, но

173
00:14:37,264 --> 00:14:41,137
этот файл не был поставлен из промежуточной области.

174
00:14:43,376 --> 00:14:48,440
Если вы вернетесь и посмотрите на index.html в своем

175
00:14:50,991 --> 00:14:56,094
редакторе, он все равно покажет состояние в конце второй фиксации,

176
00:14:56,094 --> 00:15:01,255
потому что мы вытащили этот файл, используя проверку для этого.

177
00:15:01,255 --> 00:15:06,900
Теперь, если мы хотим вернуть его обратно к тому, что было в конце третьей фиксации,

178
00:15:06,900 --> 00:15:09,470
тогда мы делаем еще одну проверку из третьей фиксации.

179
00:15:10,540 --> 00:15:16,431
Перейдя в наше командное окно, введите статус git, и

180
00:15:16,431 --> 00:15:23,558
вы заметите, что index.html помечен как измененный.

181
00:15:23,558 --> 00:15:29,661
Но он также показывает этот конкретный оператор здесь, он говорит git checkout -

182
00:15:29,661 --> 00:15:35,029
и имя файла, чтобы отменить изменения в рабочем каталоге.

183
00:15:35,029 --> 00:15:38,334
Таким образом, это один из способов, которые

184
00:15:38,334 --> 00:15:43,095
вы можете отменить изменения, внесенные в конкретный файл, соответствующий предыдущему фиксации.

185
00:15:43,095 --> 00:15:46,565
Поэтому позвольте мне восстановить этот index.html обратно к тому, что он был

186
00:15:46,565 --> 00:15:47,653
в конце третьей фиксации.

187
00:15:47,653 --> 00:15:54,315
Поэтому для этого я просто скажу git checkout -

188
00:15:54,315 --> 00:15:58,712
index.html, а затем, если я это сделаю

189
00:16:01,503 --> 00:16:05,815
, статус Git, он показывает, что мой каталог чист, и в основном мой

190
00:16:05,815 --> 00:16:10,520
каталог был восстановлен до состояния конца третьего комментария.

191
00:16:12,370 --> 00:16:16,909
Переходя к файлу в моем Visual Studio Code, я вижу, что файл был

192
00:16:16,909 --> 00:16:20,767
восстановлен обратно к тому, что он был в конце третьей фиксации.

193
00:16:20,767 --> 00:16:25,251
Поэтому, если вы внесли изменения в файл после фиксации, и вы хотите просто

194
00:16:25,251 --> 00:16:30,632
отменить эти изменения, вы можете просто проверить файл из последней фиксации.

195
00:16:30,632 --> 00:16:35,338
И тогда все ваши изменения, которые вы сделали после последней фиксации, будут отброшены в

196
00:16:35,338 --> 00:16:36,144
этой части..

197
00:16:36,144 --> 00:16:40,304
Таким образом, это некоторые основные команды, которые очень полезны для

198
00:16:40,304 --> 00:16:42,958
вас, когда вы проходите через курсы и

199
00:16:42,958 --> 00:16:48,821
специализацию, потому что вы можете совершить в конце каждого упражнения.

200
00:16:48,821 --> 00:16:51,617
И по мере продвижения вперед

201
00:16:51,617 --> 00:16:56,744
у вас все равно будет зафиксированная версия

202
00:16:56,744 --> 00:17:01,790
состояния вашей папки в конце предыдущего упражнения.

203
00:17:01,790 --> 00:17:06,249
Таким образом, если вы проводите новое упражнение, и вы обнаружите, что вы

204
00:17:06,249 --> 00:17:10,032
допустили ошибки, и вы хотите вернуться к предыдущей фиксации.

205
00:17:10,032 --> 00:17:14,832
У вас всегда будет способ сделать это с помощью команд

206
00:17:14,832 --> 00:17:18,010
, которые мы только что узнали.

207
00:17:18,010 --> 00:17:24,430
Таким образом, с этим базовым пониманием этих нескольких команд Git,

208
00:17:24,430 --> 00:17:29,427
мы сможем продолжить понимание и

209
00:17:29,427 --> 00:17:33,570
использование Git в курсах этой специализации.

210
00:17:35,560 --> 00:17:41,434
Итак, теперь мы рассмотрели сброс git для определенного файла или git reset в целом.

211
00:17:41,434 --> 00:17:47,970
Если вы просто напечатаете get reset, он восстановит вас к последней фиксации.

212
00:17:47,970 --> 00:17:51,360
Таким образом, он сбросит промежуточную область до последней фиксации,

213
00:17:51,360 --> 00:17:55,270
не нарушая изменений, которые вы сделали в вашем рабочем каталоге.

214
00:17:55,270 --> 00:17:59,270
Поэтому после сброса вы можете проверить предыдущую

215
00:17:59,270 --> 00:18:02,140
версию файла, который вы зафиксировали в предыдущей фиксации.

216
00:18:02,140 --> 00:18:05,940
Таким образом, вы можете восстановить свою папку обратно в том месте, где вы были

217
00:18:07,440 --> 00:18:10,450
в начальной точке предыдущей фиксации.

218
00:18:10,450 --> 00:18:16,037
Поэтому иногда, когда вы проходите упражнение, и вы понимаете, что совершили ошибку,

219
00:18:16,037 --> 00:18:20,082
у вас всегда есть способ вернуться к предыдущей версии.

220
00:18:20,082 --> 00:18:25,081
Поэтому с этими командами я думаю, что вы все готовы продолжать использовать

221
00:18:25,081 --> 00:18:28,651
Git на курсах этой специализации.

222
00:18:30,865 --> 00:18:33,694
Итак, в конце этого упражнения вы сделали это?

223
00:18:33,694 --> 00:18:37,459
[ МУЗЫКА]