Untitled

1
00:00:00,000 --> 00:00:01,000
Всем привет! 

2
00:00:01,440 --> 00:00:04,020
Это новое видео с реальным 
собеседованием на вакансию Middle Plus

3
00:00:04,020 --> 00:00:05,020
Senior Frontend разработчик 

4
00:00:06,600 --> 00:00:09,680
с зарплатой 300 тысяч рублей в 
Сбербанк. 

5
00:00:10,280 --> 00:00:11,280
Собеседование было не самым удачным, 

6
00:00:12,360 --> 00:00:15,660
но интересным и по итогу команда дала 
положительный фидбэк с приглашением на

7
00:00:15,660 --> 00:00:16,660
следующий этап. 

8
00:00:19,040 --> 00:00:21,240
Надеюсь, это видео будет полезно и 
поможет тем, 

9
00:00:21,360 --> 00:00:24,080
кто сейчас проходит или готовится 
проходить собеседование. 

10
00:00:24,080 --> 00:00:28,000
Также прошу вас подписаться на мой 
телеграм-канал по ссылке в описании, 

11
00:00:28,160 --> 00:00:31,480
где ты сможешь найти полезные 
материалы и фишки для трудоустройства.

12
00:00:33,240 --> 00:00:36,040
Также если тебе нужна помощь в 
трудоустройстве или 

13
00:00:36,040 --> 00:00:37,040
подготовке к собеседованию, 

14
00:00:37,640 --> 00:00:38,640
можешь воспользоваться 

15
00:00:38,640 --> 00:00:44,404
моими услугами медродства или написать
мне в телеграмм, все ссылки ты сможешь

16
00:00:44,404 --> 00:00:45,404
найти в описании. 

17
00:00:46,880 --> 00:00:49,880
Окей, ладно. Антон,

18
00:00:49,880 --> 00:00:53,800
если у тебя нечего добавить, то я бы 
пришёл к техчасти. 

19
00:00:53,800 --> 00:00:55,800
Да, нечего добавить.

20
00:00:55,800 --> 00:00:58,800
Ок, хорошо, отлично.

21
00:01:05,120 --> 00:01:06,120
Так, давай... 

22
00:01:07,320 --> 00:01:08,320
Давай начнём про Event Loop. 

23
00:01:09,520 --> 00:01:10,520
Что такое, 

24
00:01:10,680 --> 00:01:11,680
с чем едят, для чего он нужен. 

25
00:01:14,080 --> 00:01:16,076
Так, ну Event Loop это бесконечный
цикл,

26
00:01:16,880 --> 00:01:17,880
который выполняет 

27
00:01:18,040 --> 00:01:19,040
обработчики событий, 

28
00:01:20,240 --> 00:01:21,240
браузер распределяет эти обработчики 

29
00:01:22,160 --> 00:01:23,160
по очередям, 

30
00:01:23,840 --> 00:01:24,840
есть две основные очереди, 

31
00:01:25,360 --> 00:01:27,360
это микротаски и макротаски,

32
00:01:27,360 --> 00:01:28,360
ну и синхронный код. 

33
00:01:29,360 --> 00:01:30,360
К микротаскам у нас относятся 

34
00:01:32,200 --> 00:01:35,199
ну, промиссы, к функции QMicroTask,

35
00:01:35,360 --> 00:01:36,360
там mutation observer, 

36
00:01:36,920 --> 00:01:37,920
к макротаскам setTimeout, 

37
00:01:39,840 --> 00:01:40,840
ну, различные таймеры, 

38
00:01:41,440 --> 00:01:42,440
дом-эвенты. 

39
00:01:44,680 --> 00:01:45,680
Порядок выполнения вообще такой, 

40
00:01:46,720 --> 00:01:49,040
что сначала выполняется синхронный 
код, 

41
00:01:49,240 --> 00:01:50,240
потом микротаски, 

42
00:01:51,720 --> 00:01:55,080
после этого берется из очереди одна 
макротаска, 

43
00:01:55,760 --> 00:01:56,760
выполняется, 

44
00:01:56,880 --> 00:01:59,920
опять идет проверка наличия 
синхронного кода и микротасок, 

45
00:02:00,360 --> 00:02:01,360
и так по кругу. 

46
00:02:02,720 --> 00:02:04,720
Чё там? А для чего придумали вантлуп?

47
00:02:05,240 --> 00:02:06,240
Какую проблему решает? 

48
00:02:07,160 --> 00:02:08,160
Скорее всего, 

49
00:02:08,400 --> 00:02:09,400
даже не скорее всего, 

50
00:02:09,640 --> 00:02:12,280
но чтобы не было блокировки 
интерфейса. 

51
00:02:14,040 --> 00:02:15,040
Откуда она может возникнуть? 

52
00:02:15,960 --> 00:02:16,960
Если мы, например, 

53
00:02:18,160 --> 00:02:19,160
какой-то бесконечный цикл создадим. 

54
00:02:20,920 --> 00:02:26,760
И у нас заблокируется этот поток и 
перестанет работать интерфейс. 

55
00:02:29,880 --> 00:02:34,000
Ну и плюс мы запросы можем выполнять 
асинхронно. 

56
00:02:35,320 --> 00:02:36,320
Они в отдельном потоке выполняются, 

57
00:02:38,880 --> 00:02:41,600
они блокируют интерфейс благодаря 
этому. 

58
00:02:43,880 --> 00:02:47,120
А знаешь что-нибудь про однопоточные и
многопоточные приложения? 

59
00:02:49,920 --> 00:02:50,920
Мегапоточные. 

60
00:02:52,920 --> 00:02:55,960
Ну. Блин, в Джаваскрипте вообще один
поток.

61
00:02:56,800 --> 00:03:00,038
Ну, конечно, можно создать
дополнительно с помощью веб-воркеров.

62
00:03:00,920 --> 00:03:01,920
Может, тыкетом. 

63
00:03:03,160 --> 00:03:05,160
Ну, я не про Выборгера,

64
00:03:05,160 --> 00:03:09,040
я всё про Event Loop и какую проблему 
он решает. То есть,

65
00:03:09,040 --> 00:03:10,040
если взять какие-нибудь, 

66
00:03:10,040 --> 00:03:11,040
аа 

67
00:03:11,640 --> 00:03:14,780
В языке программирования типа Java или
C-Sharp, где есть полноценная 

68
00:03:14,780 --> 00:03:15,780
многопоточность, 

69
00:03:18,120 --> 00:03:20,600
то мы можем какие-то сложные 
вычисления или бесконечные циклы, 

70
00:03:20,600 --> 00:03:23,080
которые игру вынести в отдельные 
потоки, 

71
00:03:23,240 --> 00:03:25,240
и таким образом решить блокировку 
интерфейса. 

72
00:03:25,360 --> 00:03:26,360
То в JS мы так не можем сделать. 

73
00:03:28,880 --> 00:03:29,880
Вот здесь вот вопрос, 

74
00:03:29,960 --> 00:03:33,957
соответственно, если ты в коде
запустишь бесконечный цикл в JACE,

75
00:03:33,957 --> 00:03:34,957
то... 

76
00:03:35,680 --> 00:03:36,680
Справится ли EventLoop с этим или нет?

77
00:03:38,960 --> 00:03:39,960
Справится, 

78
00:03:40,880 --> 00:03:41,880
произойдет, 

79
00:03:42,440 --> 00:03:43,440
как сказать, 

80
00:03:44,320 --> 00:03:45,320
забьется колстек. 

81
00:03:47,760 --> 00:03:48,760
Ну а интерфейс-то как? 

82
00:03:49,680 --> 00:03:50,680
Зафризится или есть? 

83
00:03:51,000 --> 00:03:53,000
Да, то есть не будет отклика.

84
00:03:54,560 --> 00:03:55,560
Там будут жесткие лаги. 

85
00:03:56,640 --> 00:03:58,640
Вот, а чтоб такого не было,

86
00:03:58,640 --> 00:03:59,640
как надо код писать? 

87
00:04:01,120 --> 00:04:02,120
Так как надо писать код... 

88
00:04:04,840 --> 00:04:06,840
Ну вот, я клоню это к тому,

89
00:04:07,280 --> 00:04:09,160
что у нас вот есть асинхронный, 
допустим, 

90
00:04:09,840 --> 00:04:10,840
кода, там, вызов бэкэнда, допустим, 

91
00:04:11,600 --> 00:04:12,600
какой-то, да. 

92
00:04:13,240 --> 00:04:15,240
Ну вот, или там, какое-то вычисление,

93
00:04:15,880 --> 00:04:16,880
как бы ты это делал. 

94
00:04:17,840 --> 00:04:18,840
Синхронный код 

95
00:04:21,080 --> 00:04:22,080
выносить, 

96
00:04:22,320 --> 00:04:23,320
например, 

97
00:04:23,720 --> 00:04:24,720
в Async Await либо в Promise. 

98
00:04:26,520 --> 00:04:27,520
Так, отлично. 

99
00:04:31,280 --> 00:04:33,920
Промиссы, но они выполняются 
синхронно, 

100
00:04:34,320 --> 00:04:36,320
не блокируют основной поток, как я
говорил.

101
00:04:39,600 --> 00:04:40,600
Я не знаю, что это ты хочешь услышать.

102
00:04:42,920 --> 00:04:43,920
Ну ты... 

103
00:04:44,720 --> 00:04:48,040
выполняется айсинхронно, не блокирует 
основной поток. 

104
00:04:48,120 --> 00:04:50,800
Если в теле кроме самого напишем 
бесконечный цикл, 

105
00:04:50,840 --> 00:04:51,840
там, вайл... 

106
00:04:51,880 --> 00:04:53,880
wild rune, допустим,

107
00:04:53,880 --> 00:04:57,120
да, то это точно не заблокировать
основной поток?

108
00:04:57,480 --> 00:04:59,476
Так, в теле Промиса ты имеешь ввиду

109
00:05:01,480 --> 00:05:03,440
функции экзекьютори, которые мы 
передаем. 

110
00:05:03,720 --> 00:05:04,720
Она же выполняется тоже синхронно. 

111
00:05:07,200 --> 00:05:08,200
Ну и по идее, 

112
00:05:08,440 --> 00:05:10,400
если мы создадим бесконечное 
количество микротасок, это тоже 

113
00:05:10,400 --> 00:05:11,400
заблокирует поток, 

114
00:05:12,480 --> 00:05:14,920
потому что они выполняются одна за 
одной. 

115
00:05:16,680 --> 00:05:17,680
или ты к тому, 

116
00:05:18,560 --> 00:05:20,880
что хочешь слышать, что тяжелые 
вычисления лучше выносить в 

117
00:05:20,880 --> 00:05:21,880
SetTimeout, например? 

118
00:05:23,400 --> 00:05:26,400
Нет, нет, нет, подожди.

119
00:05:26,400 --> 00:05:27,400
Вот смотри, бесконечный цикл. 

120
00:05:27,400 --> 00:05:29,400
While, True, да?

121
00:05:29,440 --> 00:05:31,440
Все там, не знаю.

122
00:05:32,240 --> 00:05:34,680
теле в теле там можно тело пустым 
оставить или или просто консоль там 

123
00:05:34,680 --> 00:05:35,680
консоль блок что-нибудь 

124
00:05:37,760 --> 00:05:38,760
Вот мы его положили в Promise. 

125
00:05:39,400 --> 00:05:41,400
Как в Event Loop это будет 
выполняться? 

126
00:05:42,520 --> 00:05:44,680
Сколько у нас получится микротаска в 
таком случае? 

127
00:05:45,520 --> 00:05:46,520
Так. 

128
00:05:48,160 --> 00:05:49,160
Вообще одна. 

129
00:05:50,360 --> 00:05:52,360
Один, да.

130
00:05:54,480 --> 00:05:55,480
все равно заблокирует потом 

131
00:05:57,520 --> 00:06:00,800
Да, он заблокирует поток бесконечным
циклом.

132
00:06:01,080 --> 00:06:02,080
Ну и вот здесь хотелось бы услышать, 

133
00:06:02,840 --> 00:06:03,840
как запрос бэкэнда выполняется. 

134
00:06:06,760 --> 00:06:07,760
Командуйте! 

135
00:06:09,520 --> 00:06:10,520
Вот как запрос выполняется к бэкэнду. 

136
00:06:14,360 --> 00:06:15,360
Ну то есть мы вызываем внутри, 

137
00:06:16,520 --> 00:06:17,520
вызываем фич, 

138
00:06:17,760 --> 00:06:18,760
он возвращает промисс. 

139
00:06:21,480 --> 00:06:22,480
Дальше что мы делаем? 

140
00:06:24,320 --> 00:06:27,440
Но этот же запрос выполняется 
асинхронно, 

141
00:06:27,560 --> 00:06:29,560
благодаря Промису.

142
00:06:29,600 --> 00:06:32,800
То есть мы же не вызываем в запросе 
бесконечный цикл, поэтому у нас не 

143
00:06:32,800 --> 00:06:33,800
блокируется поток. 

144
00:06:38,280 --> 00:06:41,280
Ок. Ладно. Хорошо.

145
00:06:43,200 --> 00:06:46,440
Ну, это работа с сокетами в
операционной системе тут,

146
00:06:46,440 --> 00:06:47,440
ээ 

147
00:06:48,160 --> 00:06:49,160
Ну это вот, если ты говоришь, там, 

148
00:06:50,120 --> 00:06:53,000
о желании дальше прокачивать свой 
скилл максимально, 

149
00:06:53,200 --> 00:06:55,840
в какой-то момент тебе надо будет с 
этим познакомиться и узнать. 

150
00:06:56,240 --> 00:06:57,640
А так, в целом, ты правильно ответил 
тут. 

151
00:06:59,440 --> 00:07:00,440
Все хорошо, 

152
00:07:00,720 --> 00:07:01,720
так, 

153
00:07:01,960 --> 00:07:02,960
относительно Джесса я имею ввиду, 

154
00:07:03,480 --> 00:07:07,598
так, смотри, что хотел еще спросить
касательно Промесов,

155
00:07:07,598 --> 00:07:08,598
что такое синковейд, 

156
00:07:08,598 --> 00:07:09,598
как они связаны с Промесами? 

157
00:07:12,120 --> 00:07:15,120
Так, ну, async, await.

158
00:07:15,120 --> 00:07:18,960
Насколько я знаю, это синтаксический 
сохран над промиссами, там, 

159
00:07:18,960 --> 00:07:20,960
вон. Ну и плюс мы,

160
00:07:20,960 --> 00:07:24,320
когда делаем функцию асинхронной, она 
всегда возвращает промисс. 

161
00:07:25,200 --> 00:07:27,820
И уже в этих асинхронных функциях мы 
можем использовать ключевое слово 

162
00:07:27,820 --> 00:07:28,820
await. 

163
00:07:31,240 --> 00:07:34,900
Оно указывается перед промиссами и 
заставляет интерпретатора ждать, пока 

164
00:07:34,900 --> 00:07:35,900
этот промисс выполнится. 

165
00:07:38,560 --> 00:07:42,880
И только после этого переходит к 
следующей строке кода. 

166
00:07:45,600 --> 00:07:46,600
В плюс, 

167
00:07:46,920 --> 00:07:48,920
для обработки ошибок в асинхронных 
функциях мы можем использовать 

168
00:07:48,920 --> 00:07:49,920
StrikeEdge. 

169
00:07:52,320 --> 00:07:54,320
Ну да, всё правильно.

170
00:07:54,640 --> 00:07:56,640
Так. Эээ

171
00:07:59,040 --> 00:08:00,040
Погнали. 

172
00:08:00,480 --> 00:08:01,480
Еще один вопрос касательно замыкания. 

173
00:08:03,560 --> 00:08:04,560
Что такое? 

174
00:08:04,960 --> 00:08:05,960
как можно использовать. 

175
00:08:07,120 --> 00:08:12,117
Так, ну это комбинация функций и
лексического окружения,

176
00:08:12,117 --> 00:08:13,117
в котором эта функция определена. 

177
00:08:14,240 --> 00:08:19,474
То есть, когда у нас одна функция
находится внутри другой, например,

178
00:08:19,520 --> 00:08:22,800
и внутренняя функция имеет доступ к 
переменным внешней функции даже после

179
00:08:22,800 --> 00:08:23,800
того, 

180
00:08:24,200 --> 00:08:25,200
как родительская 

181
00:08:25,720 --> 00:08:26,720
функция уже завершила свое выполнение.

182
00:08:29,000 --> 00:08:34,040
Ну и еще замыкания создаются у нас 
каждый раз при создании функции. 

183
00:08:36,040 --> 00:08:37,040
М-м-м, так. 

184
00:08:39,720 --> 00:08:40,720
как они нам помогают. 

185
00:08:53,440 --> 00:08:54,440
Пока не помогает, 

186
00:08:54,560 --> 00:08:55,560
но... 

187
00:08:57,000 --> 00:09:01,700
Не знаю, может, для кого-то плюсом
будет то, что мы можем вызвать один

188
00:09:01,700 --> 00:09:06,095
раз функцию. Она сохранит свое
лексическое окружение и мы

189
00:09:07,800 --> 00:09:08,800
То есть мы вызвали функцию, 

190
00:09:09,200 --> 00:09:10,200
она вернула другую функцию, 

191
00:09:10,720 --> 00:09:11,720
и мы эту функцию, 

192
00:09:11,920 --> 00:09:12,920
которую она вернула, 

193
00:09:13,360 --> 00:09:17,640
можем еще несколько раз вызвать и 
изменять состояние. 

194
00:09:18,280 --> 00:09:19,280
родительской функции. 

195
00:09:23,040 --> 00:09:24,040
То есть такой пример могу привести. 

196
00:09:26,440 --> 00:09:27,440
Окей, 

197
00:09:27,800 --> 00:09:29,796
а вот смотри, когда мы в реакции
колбеки передаем.

198
00:09:31,400 --> 00:09:32,400
Ааа 

199
00:09:32,840 --> 00:09:33,840
Внутри Попсов это Буддин и Канин. 

200
00:09:36,520 --> 00:09:37,520
3 пропсов передаем, 

201
00:09:39,680 --> 00:09:40,680
то есть, 

202
00:09:41,200 --> 00:09:44,680
когда функцию передаем компоненту 
другому через пропсы. 

203
00:09:53,240 --> 00:09:56,520
Ну, по идее, да, у нас же все функции 
создают замыкание. 

204
00:09:57,720 --> 00:09:58,720
Данку. 

205
00:09:59,520 --> 00:10:00,520
так с прототипированием сталкивался 

206
00:10:03,720 --> 00:10:05,720
Ммм, так, ну да.

207
00:10:06,440 --> 00:10:07,440
Расскажешь, как джейсят Эльзуна? 

208
00:10:11,160 --> 00:10:15,160
Так, ну вообще это реализовано, можно
сказать, для того,

209
00:10:15,160 --> 00:10:19,120
чтобы была возможность прототипного 
какого-то наследования.

210
00:10:19,840 --> 00:10:24,440
и не было необходимости писать 
какой-то дублирующийся код. 

211
00:10:25,200 --> 00:10:29,320
Мы можем с помощью ключевого слова 
Extents наследоваться. 

212
00:10:29,600 --> 00:10:35,600
Например, один класс от другого класса
наследовать и благодаря этому избегать

213
00:10:35,600 --> 00:10:36,600
дублирования кода. 

214
00:10:38,120 --> 00:10:41,480
Плюс у всех объектов в JS есть 
свойство Prototype. 

215
00:10:43,680 --> 00:10:48,340
Оно ссылается на прототип функции 
конструктора, с помощью которого этот

216
00:10:48,340 --> 00:10:49,340
объект был создан. 

217
00:10:51,000 --> 00:10:52,000
То есть, можно сказать, 

218
00:10:52,520 --> 00:10:55,440
это ссылка на прототип родительского 
объекта. 

219
00:10:57,320 --> 00:10:58,320
Ну плюс там есть цепочка прототипов, 

220
00:11:00,360 --> 00:11:01,360
у которой на конце null, 

221
00:11:02,840 --> 00:11:03,840
и если мы обращаемся к 

222
00:11:04,200 --> 00:11:07,760
свойству объекта, то оно сначала 
ищется в текущем объекте, 

223
00:11:08,440 --> 00:11:09,440
если оно там не найдено, 

224
00:11:09,720 --> 00:11:10,720
то оно идет по цепочке прототипов. 

225
00:11:13,040 --> 00:11:15,640
Там в Proto мы также можем как-то 
мутировать, 

226
00:11:15,800 --> 00:11:16,800
добавлять новые свойства, 

227
00:11:18,040 --> 00:11:20,039
например, там новые методы.

228
00:11:21,960 --> 00:11:27,480
А вот статические методы как 
определяются, как используются? 

229
00:11:28,720 --> 00:11:29,720
статические методы, 

230
00:11:30,960 --> 00:11:35,040
мы можем их использовать без создания 
экземпляра класса 

231
00:11:36,480 --> 00:11:37,480
Но ты в своей практике используешь их?

232
00:11:39,920 --> 00:11:42,920
Так, ну, только промисол,

233
00:11:42,920 --> 00:11:43,920
например. 

234
00:11:47,680 --> 00:11:50,720
Возможно еще просто в голову только 
promise all, 

235
00:11:50,840 --> 00:11:51,840
promise race и так далее приходят. 

236
00:11:56,080 --> 00:11:58,076
Ну, может быть проверка на массив там,

237
00:11:58,240 --> 00:11:59,240
РАИ, СРАИ. 

238
00:11:59,960 --> 00:12:00,960
А, ну да, 

239
00:12:01,280 --> 00:12:02,280
там тогда вообще много, 

240
00:12:03,440 --> 00:12:06,439
наверное, есть. А хотя стоп.

241
00:12:06,439 --> 00:12:07,439
А Рэй за Рэе тоже. 

242
00:12:08,160 --> 00:12:09,160
А, ну да, это метод. 

243
00:12:11,080 --> 00:12:12,080
Ну а ты сам их определял, 

244
00:12:13,240 --> 00:12:14,240
описывал? 

245
00:12:14,840 --> 00:12:15,840
М-м 

246
00:12:16,200 --> 00:12:20,300
ну сам никогда не мутировал прототип и
нет а или ты имеешь ввиду какой-то 

247
00:12:20,300 --> 00:12:24,400
свой класс создавал создавал 
статический методов ли 

248
00:12:25,280 --> 00:12:26,280
Ля. 

249
00:12:26,880 --> 00:12:27,880
Ну да, 

250
00:12:28,320 --> 00:12:32,520
там класс для вызова back-end методов 
каких-то создавал, 

251
00:12:32,680 --> 00:12:33,680
и в нем статические методы. 

252
00:12:35,120 --> 00:12:36,120
Аппарат вызываемого абонента выключен.

253
00:12:36,720 --> 00:12:39,580
Ну а вот в каких случаях ты 
использовал статический метод, а не 

254
00:12:39,580 --> 00:12:40,580
член класса? 

255
00:12:49,840 --> 00:12:52,440
Когда нет необходимости нам создавать 
экземпляр класса для вызова этого 

256
00:12:52,440 --> 00:12:53,440
метода. 

257
00:12:56,000 --> 00:12:58,000
То есть, скорее всего,

258
00:12:58,000 --> 00:13:00,440
это когда у класса нет какого-то 
определенного состояния, которое мы 

259
00:13:00,440 --> 00:13:01,440
можем менять. 

260
00:13:05,880 --> 00:13:06,880
Ммм, окей, ладно. 

261
00:13:09,320 --> 00:13:10,320
Как по этой части еще пара вопросов, 

262
00:13:13,040 --> 00:13:14,040
сет массива чем отличается, 

263
00:13:15,280 --> 00:13:16,280
структура данных, 

264
00:13:17,520 --> 00:13:19,520
сет, мапа, рейд, чем они отличаются?

265
00:13:20,640 --> 00:13:21,640
Ммм, так. 

266
00:13:24,560 --> 00:13:25,560
Во-первых, 

267
00:13:26,240 --> 00:13:27,240
сет — это, можно сказать, 

268
00:13:28,040 --> 00:13:30,680
коллекция для хранения каких-то 
уникальных значений. 

269
00:13:33,200 --> 00:13:34,200
Ну и плюс, 

270
00:13:34,400 --> 00:13:38,240
в отличие от массива, у неё есть набор
методов, 

271
00:13:38,360 --> 00:13:39,360
например там set, 

272
00:13:40,080 --> 00:13:42,079
get, хотя get нет.

273
00:13:44,400 --> 00:13:45,400
Я думаю понятно, 

274
00:13:45,720 --> 00:13:46,720
Set есть метод, 

275
00:13:47,040 --> 00:13:48,040
Entries и так далее, 

276
00:13:49,600 --> 00:13:52,800
у Map тоже есть набор своих методов, в
отличие от Massive, 

277
00:13:53,880 --> 00:13:54,880
по типу Entries, Cases и так далее. 

278
00:13:59,160 --> 00:14:05,160
И в Map это коллекция для хранения 
значений в виде ключ-значения, 

279
00:14:06,240 --> 00:14:09,396
и в отличии, ну скорее его можно
сравнить с объектом.

280
00:14:09,396 --> 00:14:12,616
И в отличии от объекта в Map ключами 
могут быть не только String или 

281
00:14:12,616 --> 00:14:13,616
Symbol, 

282
00:14:16,040 --> 00:14:21,040
а какие-то произвольные типы данных по
типу массивов, 

283
00:14:21,160 --> 00:14:22,160
объектов и так далее. 

284
00:14:25,560 --> 00:14:31,560
И плюс мы при инициализации мэппи-сет 
вызываем их с помощью оператора нью, 

285
00:14:33,320 --> 00:14:36,320
а массивы мы просто объявляем с 
помощью квадратных скобочек. 

286
00:14:38,600 --> 00:14:42,036
Конечно, их можно с помощью ньюэр
рейтуржа объявлять.

287
00:14:45,200 --> 00:14:46,200
Это был Станислав Кеслич. 

288
00:14:49,000 --> 00:14:50,000
Окей. Ладно. 

289
00:14:51,880 --> 00:14:53,960
Так, а про разборщик мусора ты знаешь 
что-нибудь? 

290
00:14:55,960 --> 00:14:58,960
Ну, немного знаю. Там,

291
00:14:58,960 --> 00:15:02,840
когда мы объявляем какие-то 
переменные, они в кучу складываются,

292
00:15:03,640 --> 00:15:04,640
занимают там память. 

293
00:15:06,280 --> 00:15:08,280
И, например, мы объявили объект,

294
00:15:08,400 --> 00:15:09,400
и этот объект нигде не используется. 

295
00:15:11,720 --> 00:15:16,680
И сборщик мусора при проходе находит 
такие объекты, 

296
00:15:16,760 --> 00:15:17,760
которые нигде не используются в коде. 

297
00:15:19,080 --> 00:15:22,960
И если на них нет ссылок, то он 
убирает их из памяти. 

298
00:15:26,880 --> 00:15:29,960
В каких случаях сборщик мусора 
начинает работать? 

299
00:15:36,840 --> 00:15:37,840
Эх, сборщик мусора. 

300
00:15:40,040 --> 00:15:42,040
Блин, насколько я помню, он...

301
00:15:43,520 --> 00:15:49,520
периодически проходит и ищет ссылки на
ненужный код. 

302
00:15:52,440 --> 00:15:53,440
Наверное, 

303
00:15:53,560 --> 00:15:55,556
не скажу, в каких случаях он начинает
работать.

304
00:15:56,080 --> 00:15:58,080
По-моему, всегда.

305
00:16:00,040 --> 00:16:04,039
Да, окей, ладно, ну то есть ты имеешь
ввиду как в конце

306
00:16:05,520 --> 00:16:09,440
event loop запускать заборщик мусора и
удалять ненужные ссылки.

307
00:16:12,880 --> 00:16:13,880
Для чего нам надо, давай так, 

308
00:16:14,920 --> 00:16:15,920
ответьте на вопрос, 

309
00:16:15,920 --> 00:16:17,760
для чего нам надо выпускать борщ в 
мусор? 

310
00:16:18,640 --> 00:16:19,640
для того, 

311
00:16:19,800 --> 00:16:20,800
чтобы освободить память, 

312
00:16:21,920 --> 00:16:22,920
которую они используют. 

313
00:16:25,320 --> 00:16:27,319
для того, чтобы освободить память.

314
00:16:30,320 --> 00:16:31,320
Ну и соответственно, 

315
00:16:31,400 --> 00:16:37,400
если бы ты такой функционал писал, то 
когда бы я вызывал такой сборщик? 

316
00:16:39,560 --> 00:16:40,560
Угу. 

317
00:16:45,080 --> 00:16:46,080
Сейчас подумаю немного. 

318
00:16:50,160 --> 00:16:52,400
Не знаю, в голову приходит после 
выполнения какого-то определенной 

319
00:16:52,400 --> 00:16:53,400
части кода. 

320
00:17:04,000 --> 00:17:05,000
Ууу 

321
00:17:10,760 --> 00:17:11,760
Что-то больше не приходит в голову. 

322
00:17:13,840 --> 00:17:14,840
Ну, 

323
00:17:14,840 --> 00:17:17,800
если у тебя приложение будет каждый 
раз после выполнения там какого-то 

324
00:17:17,800 --> 00:17:18,800
кода, ну, я так прозываю, EventLoop'a.

325
00:17:20,560 --> 00:17:22,559
Может быть, я не прав.

326
00:17:24,400 --> 00:17:25,400
запускать какой-то там процесс, 

327
00:17:25,960 --> 00:17:27,960
соответственно, по

328
00:17:28,200 --> 00:17:31,960
утилизации, соответственно, ресурсов, 
то это бы, наверное, приводило к 

329
00:17:32,400 --> 00:17:33,400
нескольким проблемам. 

330
00:17:34,880 --> 00:17:35,880
Мы ранее с тобой говорили о том, 

331
00:17:36,720 --> 00:17:37,720
что JS однопоточный, 

332
00:17:38,520 --> 00:17:40,240
соответственно, надо избегать таких 
процессов. 

333
00:17:41,960 --> 00:17:42,960
Как думаешь или знаешь, 

334
00:17:44,640 --> 00:17:46,640
соответственно, вот о...

335
00:17:47,560 --> 00:17:49,960
Ограничения по памяти есть у 
приложения? 

336
00:17:54,560 --> 00:17:55,560
Ограничение попямься, 

337
00:17:55,560 --> 00:17:56,560
да. 

338
00:18:00,440 --> 00:18:02,440
Ну вот, если,

339
00:18:02,920 --> 00:18:03,920
допустим, 

340
00:18:04,000 --> 00:18:05,000
там, 

341
00:18:05,000 --> 00:18:06,780
вкладка в браузере начинает 
приближаться к этому лимиту, там, 

342
00:18:06,780 --> 00:18:07,780
условно, 

343
00:18:08,600 --> 00:18:09,600
4 гигабайта откидает, 

344
00:18:10,160 --> 00:18:11,160
то... 

345
00:18:12,120 --> 00:18:13,120
Вау! 

346
00:18:14,680 --> 00:18:16,920
Может логичнее в этот момент запускать
сборщик мусора? 

347
00:18:17,520 --> 00:18:20,440
А, ты имеешь ввиду, когда появляются 
проблемы с памятью? 

348
00:18:21,360 --> 00:18:22,360
Ну да. 

349
00:18:24,160 --> 00:18:27,160
Ну, скорее всего, да.

350
00:18:31,480 --> 00:18:32,480
Так, ладно, 

351
00:18:32,640 --> 00:18:33,640
окей, с ЦСС, 

352
00:18:37,080 --> 00:18:38,080
с какими припроцессорами работал? 

353
00:18:41,600 --> 00:18:42,600
СССР и ЛССР 

354
00:18:46,520 --> 00:18:47,520
с методологиями, 

355
00:18:51,000 --> 00:18:52,000
с которыми сталкивался и подходами. 

356
00:18:52,800 --> 00:18:55,800
у Так, на методологии.

357
00:18:55,800 --> 00:18:56,800
только с пэм, 

358
00:18:57,120 --> 00:18:58,120
насколько я помню, 

359
00:18:58,520 --> 00:19:03,280
блок-элемент-модификатор и из 
подходов, наверное, 

360
00:19:03,480 --> 00:19:04,480
модульный css. 

361
00:19:06,840 --> 00:19:07,840
А модульный CSS какую проблему решает?

362
00:19:09,160 --> 00:19:10,160
Для чего его придумали? 

363
00:19:11,080 --> 00:19:14,080
так, ну, изоляция стилей,

364
00:19:14,080 --> 00:19:16,080
то есть, чтобы нам,

365
00:19:16,080 --> 00:19:21,160
чтобы не было дублирующихся имен и не
приходилось придумывать

366
00:19:21,160 --> 00:19:25,720
и городить какие-то большие имена 
классов. Угу, окей,

367
00:19:25,720 --> 00:19:26,720
а как сделать так, 

368
00:19:27,040 --> 00:19:28,040
чтобы у селектора в стиле был... 

369
00:19:30,840 --> 00:19:31,840
максимально возможный вес, 

370
00:19:32,920 --> 00:19:34,920
то есть именно он применялся к 
компоненту. 

371
00:19:37,120 --> 00:19:38,120
с помощью импотент можем реализовать 

372
00:19:40,280 --> 00:19:41,280
еще какие-то варианты есть 

373
00:19:45,960 --> 00:19:46,960
написать стили через inline-стили, 

374
00:19:48,920 --> 00:19:49,920
либо каким-то образом повысить 

375
00:19:52,680 --> 00:19:55,800
специфичность селектора, там, создать 
какую-то вложенность. 

376
00:19:59,920 --> 00:20:00,920
Ммм, окей. 

377
00:20:04,880 --> 00:20:05,880
Давай еще немного про Реакт. 

378
00:20:10,960 --> 00:20:13,960
Пум-пум, пум-пум. Так, а что такое
виртуал-дом?

379
00:20:15,760 --> 00:20:16,760
Так, ну, виртуал-дом — это, 

380
00:20:17,960 --> 00:20:20,840
можно сказать, какая-то легковестная
копия дом-дерева.

381
00:20:21,560 --> 00:20:24,360
Она хранится в оперативной памяти и 
синхронизируется с этим реальным 

382
00:20:24,360 --> 00:20:25,360
дом-деревом. 

383
00:20:28,880 --> 00:20:33,200
Основная цель она помогает избежать 
прямой работы с домом, так как это 

384
00:20:33,200 --> 00:20:34,200
влияет на производительность. 

385
00:20:38,680 --> 00:20:42,420
И у нас при каждом изменении дом в 
чистом джейсе происходят тяжеловесные 

386
00:20:42,420 --> 00:20:43,420
операции для браузера по типу layout, 

387
00:20:46,320 --> 00:20:47,320
painting, reflow и так далее. 

388
00:20:49,520 --> 00:20:53,560
Виртуал дом хранится в виде обычного 
джава скрипт объекта, 

389
00:20:54,360 --> 00:20:57,720
и благодаря этому мы можем свободно 
изменять его свойства, не затрагивая 

390
00:20:57,720 --> 00:20:58,720
дом дерева, пока это не понадобится. 

391
00:21:02,280 --> 00:21:06,600
и потом точно пакетно обновлять этот 
дом-дерево. 

392
00:21:07,800 --> 00:21:08,800
Вообще принцип работы примерно такой, 

393
00:21:10,880 --> 00:21:15,160
что при изменении состояния 
обновляется виртуал дом,

394
00:21:15,160 --> 00:21:17,820
после обновления виртуал дом 
сравнивается текущая версия с 

395
00:21:17,820 --> 00:21:18,820
предыдущей 

396
00:21:20,320 --> 00:21:26,320
и вычисляется разница между этими 
деревьями и потом точно обновляется 

397
00:21:27,360 --> 00:21:28,360
только те части реального домозерия, 

398
00:21:29,080 --> 00:21:30,080
которые действительно изменились. 

399
00:21:32,520 --> 00:21:33,520
Ну плюс там реактор реализует