1
00:00:00,000 --> 00:00:04,722
[MUSIC]

2
00:00:04,722 --> 00:00:10,212
Когда мы говорили об услугах в предыдущем модуле, я упомянул

3
00:00:10,212 --> 00:00:16,070
о обещаниях, а потом пообещал, что вернусь к обещаниям в этом модуле.

4
00:00:17,360 --> 00:00:20,360
Итак, вот мы, я собираюсь выполнить свое обещание вам.

5
00:00:22,090 --> 00:00:28,310
Синхронные вычисления повсюду во всемирной паутине.

6
00:00:28,310 --> 00:00:31,410
И как работает интернет.

7
00:00:32,880 --> 00:00:35,810
Если вы идете из мира последовательного программирования,

8
00:00:37,040 --> 00:00:41,640
обертывание головы вокруг синхронного вычисления занимает довольно много усилий.

9
00:00:42,680 --> 00:00:54,680
Было много попыток сделать асинхронные вычисления настолько безболезненными, насколько это возможно для людей, переходящих в него из книги последовательных вычислений.

10
00:00:56,850 --> 00:01:01,470
Одна из таких попыток заключается в том, чтобы облегчить асинхронные вычисления

11
00:01:01,470 --> 00:01:04,790
, это обещания.

12
00:01:06,040 --> 00:01:10,304
Как мы понимаем, когда мы делаем любой запрос на любую услугу

13
00:01:10,304 --> 00:01:15,220
или на бэкенд-сервер,

14
00:01:16,530 --> 00:01:21,180
это займет некоторое время, чтобы результаты стали доступными для нас.

15
00:01:22,550 --> 00:01:30,840
Если мы делаем такой запрос в то время как мы продолжаем нашу работу,

16
00:01:30,840 --> 00:01:35,680
то существует высокая вероятность того, что наши вычисления застрянут в точке,

17
00:01:35,680 --> 00:01:37,890
ожидая результатов.

18
00:01:37,890 --> 00:01:44,070
Это нет-нет с точки зрения хорошего пользовательского опыта.

19
00:01:46,090 --> 00:01:52,420
Поэтому важно, чтобы всякий раз, когда ваши результаты будут занимать время

20
00:01:52,420 --> 00:01:57,660
, вы могли двигаться вперед, не дожидаясь правил.

21
00:01:57,660 --> 00:02:01,492
И именно здесь асинхронные вычисления приходят вам в преимущество.

22
00:02:01,492 --> 00:02:04,640
В асинхронных вычислениях, когда вы отправляете запрос

23
00:02:04,640 --> 00:02:07,800
вы ожидаете, что результаты вернутся позже, а

24
00:02:07,800 --> 00:02:12,720
вы должны иметь возможность иметь дело с тем фактом, базовые результаты возвращаются в то время

25
00:02:14,490 --> 00:02:20,410
гораздо позже, чем там, где вы были в момент, когда вы сделали запрос.

26
00:02:21,830 --> 00:02:25,710
Обещания предоставляют нам способ справиться с этим.

27
00:02:26,790 --> 00:02:32,540
Давайте рассмотрим обещания чуть более подробно в этой лекции.

28
00:02:32,540 --> 00:02:35,910
И тогда мы также увидим использование обещаний

29
00:02:35,910 --> 00:02:39,490
в нашем угловом приложении немного позже.

30
00:02:39,490 --> 00:02:44,750
Обещания, общая концепция является очень обширной областью сама по себе.

31
00:02:44,750 --> 00:02:49,030
И в этом курсе у меня нет времени на детали обещаний.

32
00:02:49,030 --> 00:02:51,780
Это станет целым курсом само по себе.

33
00:02:51,780 --> 00:02:56,950
Я дам вам только основные обещания, которые необходимы

34
00:02:56,950 --> 00:03:02,490
нам, чтобы понять, как использовать обещания в рамках нашего углового приложения.

35
00:03:02,490 --> 00:03:07,230
Я предоставлю вам много лидов к дополнительным

36
00:03:07,230 --> 00:03:11,380
ресурсам, где вы можете пойти и изучить обещания более подробно.

37
00:03:13,110 --> 00:03:17,230
Итак, возвращаясь к этому вопросу, что именно такое обещание?

38
00:03:17,230 --> 00:03:21,690
Обещание - это механизм, который поддерживает асинхронные вычисления.

39
00:03:21,690 --> 00:03:26,580
Я просто дал длинное объяснение того, почему асинхронные вычисления

40
00:03:26,580 --> 00:03:31,340
необходимы для работы Интернета.

41
00:03:31,340 --> 00:03:36,720
Теперь, используя обещание, обещание предоставляет механизм или

42
00:03:36,720 --> 00:03:42,760
прокси для значения, которое недоступно в момент, когда вы его запрашиваете.

43
00:03:42,760 --> 00:03:46,050
Таким образом, обещание вернет вам обещание, сказав, что

44
00:03:46,050 --> 00:03:51,430
, когда результат станет доступным, он вернется и доставит вам результаты.

45
00:03:51,430 --> 00:03:56,850
Таким образом, обещание возвращает вам прокси-объект, и вы держитесь за прокси-объект.

46
00:03:56,850 --> 00:04:02,030
И этот прокси-объект даст вам доступ к результатам, когда они станут доступны.

47
00:04:02,030 --> 00:04:07,290
И есть метод в том, как вы ждете результатов.

48
00:04:07,290 --> 00:04:11,560
Вы на самом деле не приостанавливаете свои вычисления в этот момент, вместо этого вы

49
00:04:13,110 --> 00:04:19,948
настраиваете способ принятия результатов, когда он возвращается из этого обещания.

50
00:04:19,948 --> 00:04:23,780
В двух словах,

51
00:04:23,780 --> 00:04:27,960
обещание представляет собой значение, которое будет доступно в будущем.

52
00:04:27,960 --> 00:04:29,680
Он также может быть немедленно доступен,

53
00:04:29,680 --> 00:04:32,960
в этом случае обещание вернет значение немедленно.

54
00:04:32,960 --> 00:04:37,940
Но в случае, если он должен вернуть значение в будущую дату, то он дает вам

55
00:04:37,940 --> 00:04:42,040
обещание, что это значение, когда оно станет доступным, будет возвращено вам.

56
00:04:43,400 --> 00:04:47,820
Всегда есть возможность, что обещание не может быть выполнено,

57
00:04:47,820 --> 00:04:50,730
, потому что результаты недоступны по какой-либо причине.

58
00:04:51,950 --> 00:04:57,150
В этом случае вам будет доставлена ошибка, или отклонение будет доставлено

59
00:04:57,150 --> 00:05:02,430
, и вам предстоит разобраться с тем, что обещание было отклонено.

60
00:05:03,930 --> 00:05:06,890
Мы смотрим, как мы справляемся с этим в следующем слайде.

61
00:05:07,950 --> 00:05:11,180
Как мы узнали ранее, обещание является прокси-сервером для

62
00:05:11,180 --> 00:05:15,080
то, что должно произойти в будущем или может никогда не произойти в будущем.

63
00:05:15,080 --> 00:05:19,745
Так что обещание, когда оно будет дано вам, будет в состоянии ожидания.

64
00:05:20,860 --> 00:05:25,130
Теперь, когда обещание решится, то есть результаты становятся доступными и

65
00:05:25,130 --> 00:05:30,080
обещание может доставить вам результаты, то обещание решится или

66
00:05:30,080 --> 00:05:31,490
выполнит.

67
00:05:31,490 --> 00:05:37,130
И в этом случае обещание перейдет из состояния ожидания в разрешение или

68
00:05:37,130 --> 00:05:38,490
состояние выполнения.

69
00:05:38,490 --> 00:05:41,220
Таким образом, в этот момент ваши результаты доступны для вас.

70
00:05:42,540 --> 00:05:48,760
Есть небольшой шанс, что обещание может быть отклонено из-за ошибки,

71
00:05:48,760 --> 00:05:50,590
или какой бы то ни было причиной.

72
00:05:50,590 --> 00:05:53,280
В этом удаленном случае

73
00:05:53,280 --> 00:06:02,209
вам будет доставлен отказ, и в этом случае обещание будет считаться в отклоненном состоянии, когда отклонение будет доставлено.

74
00:06:03,380 --> 00:06:06,710
Итак, когда вы генерируете обещание, как я уже сказал,

75
00:06:06,710 --> 00:06:10,560
обещание - это прокси-объект, который доставляется вам.

76
00:06:10,560 --> 00:06:14,580
Итак, когда вы даете обещание кому-то, обещание внутренне будет иметь

77
00:06:14,580 --> 00:06:17,500
функцию, которая будет иметь дело как с разрешением, так и

78
00:06:17,500 --> 00:06:20,310
вариантов отклонения внутри.

79
00:06:21,480 --> 00:06:22,540
Когда вы пишете код,

80
00:06:22,540 --> 00:06:28,190
вы увидите, что вы будете писать код как новый Promise (функция (разрешение, отклонение).

81
00:06:28,190 --> 00:06:33,350
Так что независимо от того, будет ли он разрешен или он будет отклонен, мы должны иметь возможность отправить

82
00:06:33,350 --> 00:06:38,290
обратно информацию тому, кому мы дали обещание.

83
00:06:39,570 --> 00:06:41,600
Как мы это делаем в коде?

84
00:06:41,600 --> 00:06:44,040
Давайте посмотрим на это в следующем слайде.

85
00:06:45,280 --> 00:06:50,430
Вот пример того, как обещание настроено в коде.

86
00:06:50,430 --> 00:06:53,870
Действительно, этот пример является результатом упражнения, которое вы сделаете

87
00:06:53,870 --> 00:06:55,850
немного позже.

88
00:06:55,850 --> 00:07:01,100
Таким образом, когда мы настраиваем наш сервис

89
00:07:01,100 --> 00:07:06,830
возвращает обещание компоненту, который запрашивает данные из сервиса.

90
00:07:06,830 --> 00:07:08,368
Итак, когда обещание возвращается,

91
00:07:08,368 --> 00:07:13,810
, то обещание возврата доступно вам как объект.

92
00:07:13,810 --> 00:07:18,190
И это обещание предоставляет два метода: метод then и catch.

93
00:07:19,420 --> 00:07:23,416
Теперь, тогда, обещание успешно решено.

94
00:07:23,416 --> 00:07:28,300
Тогда обещание приведет

95
00:07:28,300 --> 00:07:32,810
к вызову решения.

96
00:07:32,810 --> 00:07:36,960
Как вы видели, обещание построено, и внутри обещания

97
00:07:36,960 --> 00:07:42,170
у вас есть функция, разрешение и отклонение, как два параметра.

98
00:07:42,170 --> 00:07:46,820
Поэтому, если обещание успешно сможет доставить результат,

99
00:07:46,820 --> 00:07:51,680
, то он вызовет метод разрешения, а затем вернет результат вам.

100
00:07:51,680 --> 00:07:53,520
Где результат становится реальностью?

101
00:07:54,820 --> 00:07:58,820
Когда вы пишете код, ожидающий

102
00:07:58,820 --> 00:08:04,400
обещания, вы бы указали, что делать, когда обещание возвращает результат

103
00:08:04,400 --> 00:08:09,370
в опции then для этого обещания.

104
00:08:09,370 --> 00:08:14,590
Так скажем, например, вы бы сказали getDishes.then и внутри затем

105
00:08:14,590 --> 00:08:18,810
вы поставите функцию, которая будет иметь дело с результатом, когда он придет в.

106
00:08:20,370 --> 00:08:25,700
Если обещание не может решить правильно, то оно отклонит

107
00:08:25,700 --> 00:08:28,570
с ошибкой, отправляемой вам обратно.

108
00:08:28,570 --> 00:08:31,600
Ошибка является объектом ошибки, который будет отправлен вам обратно.

109
00:08:31,600 --> 00:08:36,560
Поэтому, когда их обещание отклоняется, вы имеете дело с

110
00:08:36,560 --> 00:08:41,020
отклонением, используя уловки в вашем коде.

111
00:08:41,020 --> 00:08:47,460
Таким образом, в пределах улова вы предоставите функцию, которая будет иметь дело с ошибкой.

112
00:08:47,460 --> 00:08:51,470
Например, вы можете просто вывести сообщение об ошибке,

113
00:08:51,470 --> 00:08:56,770
журнал консоли и справиться с ошибкой таким образом.

114
00:08:56,770 --> 00:09:01,080
Или у вас может быть более сложный способ обработки ошибки.

115
00:09:01,080 --> 00:09:06,670
Это будет предоставлено в опции catch, которую вы даете для этого кода обещания

116
00:09:06,670 --> 00:09:12,130
на вашей стороне, когда обещание доставляет вам отклонение.

117
00:09:12,130 --> 00:09:17,690
Так вот как обе стороны монеты справляются с обещаниями.

118
00:09:17,690 --> 00:09:21,160
С одной стороны, вам отправляется объект обещания, и

119
00:09:21,160 --> 00:09:24,730
, когда вы получаете объект обещания, с объектом обещания, вы либо делаете

120
00:09:24,730 --> 00:09:28,300
тогда, и поймать, поэтому вы должны реализовать как тогдашние, так и

121
00:09:28,300 --> 00:09:33,510
метрики catch, измененные на этот объект обещания.

122
00:09:34,780 --> 00:09:39,910
И затем, от этого обещания в сторону, если обещание результат правильно,

123
00:09:39,910 --> 00:09:44,757
тогда будет вызвано решение и, таким образом, результат будет доставлен

124
00:09:44,757 --> 00:09:48,770
в тогдашнем методе вашего обещания.

125
00:09:48,770 --> 00:09:51,175
Если обещание отклоняется,

126
00:09:51,175 --> 00:09:55,530
вызов отклонить доставит ошибку в ваш улов.

127
00:09:56,760 --> 00:10:01,725
Так вот как вы будете реализовывать код с помощью обещаний.

128
00:10:01,725 --> 00:10:07,375
Мы рассмотрим пример в упражнении, которое следует за этой лекцией.

129
00:10:07,375 --> 00:10:09,786
Теперь, очевидно, вопрос, который я задаю, почему обещания?

130
00:10:11,347 --> 00:10:13,927
Позже, когда мы имеем дело с Node JS,

131
00:10:13,927 --> 00:10:18,237
мы будем иметь дело с тем, как мы можем построить обратные вызовы.

132
00:10:18,237 --> 00:10:21,677
И я объясню детали обратных вызовов и способ справиться с обратными вызовами

133
00:10:21,677 --> 00:10:29,920
, когда мы охватываем узел JS в последнем курсе этой специализации.

134
00:10:29,920 --> 00:10:37,400
Callbacks имеет проблему создания того, что называется обратным аддом.

135
00:10:37,400 --> 00:10:40,000
Таким образом, у вас есть сильно вложенный код обратного вызова

136
00:10:40,000 --> 00:10:44,650
, который очень сложно понять, что он пытается сделать.

137
00:10:44,650 --> 00:10:50,970
Обещания предоставляют способ решения этой адской проблемы обратного вызова.

138
00:10:50,970 --> 00:10:55,270
Но на данный момент мы концентрируемся на Angular, я просто упомяну этот момент.

139
00:10:55,270 --> 00:10:59,050
И тогда мы вернемся, чтобы разобраться с этим вопросом в последнем курсе.

140
00:11:00,760 --> 00:11:05,600
Другим преимуществом использования обещаний является то, что обещания могут быть изменены.

141
00:11:05,600 --> 00:11:08,780
Обещание, когда он доставляет результат в ячейку,

142
00:11:08,780 --> 00:11:11,130
вы можете сгенерировать другое обещание и возврат, и

143
00:11:11,130 --> 00:11:16,280
, что обещание может быть обработано путем прицепления другого метода затем к этому и так далее.

144
00:11:16,280 --> 00:11:21,720
Таким образом, вы можете связать набор затем методов вместе, чтобы иметь дело с

145
00:11:21,720 --> 00:11:23,470
обещает один за другим.

146
00:11:25,610 --> 00:11:31,850
Если результат сразу доступен или если вы собираетесь отклонить немедленно,

147
00:11:31,850 --> 00:11:37,190
то обещание предоставляет метод немедленного возвращения, не дожидаясь

148
00:11:37,190 --> 00:11:39,900
обещание либо разрешить, либо отклонить.

149
00:11:39,900 --> 00:11:45,766
В этом случае вы просто скажете обещание с капиталом P.resolve и

150
00:11:45,766 --> 00:11:52,243
Promise.reject, а затем вернете либо результат, либо ошибку немедленно.

151
00:11:52,243 --> 00:11:57,079
В первом упражнении мы будем иметь дело с этим методом возврата значения

152
00:11:57,079 --> 00:11:59,480
из нашего сервиса нашим компонентам.

153
00:12:00,920 --> 00:12:04,010
Во второй части упражнения мы рассмотрим

154
00:12:04,010 --> 00:12:09,820
ситуацию, когда обещание решится по прошествии определенного времени.

155
00:12:09,820 --> 00:12:13,400
А также в рамках нашей составляющей мы должны иметь дело с тем, что

156
00:12:13,400 --> 00:12:20,280
результаты возвращаются чуть позже, чем когда вы попросите результат.

157
00:12:22,485 --> 00:12:25,679
С этим быстрым пониманием обещаний

158
00:12:25,679 --> 00:12:30,393
давайте перейдем к следующему упражнению, где мы будем иметь дело с обещаниями.

159
00:12:30,393 --> 00:12:33,769
[МУЗЫКА]