WEBVTT

1
00:00:01.130 --> 00:00:04.620
<v Narrator>Moving on let's now talk about the rest pattern</v>

2
00:00:04.620 --> 00:00:06.680
and also rest parameters

3
00:00:08.610 --> 00:00:12.880
and the rest pattern looks exactly like the spread operator.

4
00:00:12.880 --> 00:00:16.292
So it has the same syntax with the three dots

5
00:00:16.292 --> 00:00:20.670
but it actually does the opposite of the spread operator.

6
00:00:20.670 --> 00:00:24.230
Now that doesn't seem to make much sense, right?

7
00:00:24.230 --> 00:00:27.190
But let me explain, so remember

8
00:00:27.190 --> 00:00:30.990
that we used the spread operator to build new arrays

9
00:00:30.990 --> 00:00:34.590
or to pass multiple values into a function.

10
00:00:34.590 --> 00:00:38.580
So those are the two use cases of the spread operator

11
00:00:38.580 --> 00:00:41.530
and in both cases, we use the spread operator

12
00:00:41.530 --> 00:00:45.700
to expand an array into individual elements.

13
00:00:45.700 --> 00:00:49.037
Now, the rest pattern uses the exact same syntax

14
00:00:49.037 --> 00:00:52.400
however, to collect multiple elements

15
00:00:52.400 --> 00:00:55.100
and condense them into an array.

16
00:00:55.100 --> 00:00:58.250
so that's really the opposite of spread

17
00:00:58.250 --> 00:01:01.470
The spread operator is to unpack an array

18
00:01:01.470 --> 00:01:05.810
while rest is to pack elements into an array

19
00:01:05.810 --> 00:01:08.010
and since that sounds really confusing

20
00:01:08.010 --> 00:01:11.235
let's write some coat and let's start by exploring

21
00:01:11.235 --> 00:01:14.410
the use case of building a race.

22
00:01:14.410 --> 00:01:16.610
So just to recap in the last lecture

23
00:01:16.610 --> 00:01:20.053
we use to spread array like this.

24
00:01:20.970 --> 00:01:23.080
So we wanted to create a new array

25
00:01:24.230 --> 00:01:25.980
based on an existing, array

26
00:01:27.630 --> 00:01:30.383
and so we used the spread operator to expand that.

27
00:01:32.640 --> 00:01:36.370
So here we are still using the spread syntax

28
00:01:36.370 --> 00:01:38.470
and we know that this is the spread syntax

29
00:01:38.470 --> 00:01:41.930
because we are using it on the right hand side

30
00:01:41.930 --> 00:01:45.900
of the assignment operator, so of the equal sign.

31
00:01:45.900 --> 00:01:48.150
So let me actually write that here,

32
00:01:48.150 --> 00:01:53.150
spread, because on the right side of the assignment operator

33
00:01:56.140 --> 00:01:59.480
however, we can also use it on the left hand side

34
00:01:59.480 --> 00:02:03.780
of the assignment operator together with destructuring.

35
00:02:03.780 --> 00:02:07.070
So now we're mixing kind of everything together here

36
00:02:07.070 --> 00:02:09.233
but bear with me here.

37
00:02:10.525 --> 00:02:14.690
So let's say that we are destructuring this array

38
00:02:14.690 --> 00:02:16.800
so let me first write the array here

39
00:02:16.800 --> 00:02:20.200
two, three, four, and five

40
00:02:21.470 --> 00:02:24.620
and so let's say I want to take the first element

41
00:02:24.620 --> 00:02:27.410
and store it in variable A

42
00:02:27.410 --> 00:02:30.970
the second element to store in variable B

43
00:02:30.970 --> 00:02:34.150
and now I can here use the rest pattern.

44
00:02:34.150 --> 00:02:39.150
So the same syntax and now let's call this others

45
00:02:39.740 --> 00:02:41.860
and so here it is the rest syntax

46
00:02:41.860 --> 00:02:44.040
because it's on the left hand side

47
00:02:44.040 --> 00:02:45.603
of the assignment operator,

48
00:02:47.470 --> 00:02:50.170
first write that and then see result

49
00:02:50.170 --> 00:02:55.170
because on left side of the equal sign

50
00:02:56.770 --> 00:02:59.200
and so now let's log A, B

51
00:03:00.390 --> 00:03:03.040
and the others, whatever that's gonna be

52
00:03:04.210 --> 00:03:09.140
and so one, two and then basically the rest

53
00:03:09.140 --> 00:03:11.450
of the elements that we did not select

54
00:03:11.450 --> 00:03:14.680
into the A and the B variables.

55
00:03:14.680 --> 00:03:17.040
So what is happening here?

56
00:03:17.040 --> 00:03:18.670
Well, just like before

57
00:03:18.670 --> 00:03:22.080
the first and the second elements become this first

58
00:03:22.080 --> 00:03:26.950
and second variables, but then here comes the rest pattern

59
00:03:26.950 --> 00:03:29.786
and so it's called rest because it will take

60
00:03:29.786 --> 00:03:31.650
the rest of the elements.

61
00:03:31.650 --> 00:03:34.580
So the remaining elements of the array

62
00:03:34.580 --> 00:03:37.070
and then put them into a new array

63
00:03:37.070 --> 00:03:39.930
and in this case, we call this array others.

64
00:03:39.930 --> 00:03:41.730
So as I said in the beginning,

65
00:03:41.730 --> 00:03:44.150
the rest pattern basically collects

66
00:03:44.150 --> 00:03:46.410
the elements that are unused

67
00:03:46.410 --> 00:03:48.563
in the destructuring assignment.

68
00:03:51.490 --> 00:03:54.540
So let's see another example here

69
00:03:54.540 --> 00:03:57.140
and this will show you that we can actually use

70
00:03:57.140 --> 00:04:02.140
the three dots on both sides of the assignment operator.

71
00:04:02.390 --> 00:04:05.160
So let's say that we have this array

72
00:04:05.160 --> 00:04:07.350
which will be the entire menu

73
00:04:07.350 --> 00:04:09.310
and so we already know how to build that

74
00:04:09.310 --> 00:04:10.853
using the spread operator.

75
00:04:11.700 --> 00:04:14.890
So we go to restaurant dot main menu

76
00:04:16.560 --> 00:04:17.430
so that's dot

77
00:04:18.310 --> 00:04:20.920
so we take all the elements out of that array

78
00:04:20.920 --> 00:04:22.890
and put it into a new array

79
00:04:22.890 --> 00:04:25.180
and then into this new array

80
00:04:25.180 --> 00:04:29.493
we also put the starter menu, okay?

81
00:04:30.600 --> 00:04:33.290
So this is going to be an array, a big array

82
00:04:33.290 --> 00:04:36.410
with all the entire menu, but now

83
00:04:36.410 --> 00:04:39.860
we can actually also use the rest pattern here

84
00:04:39.860 --> 00:04:43.033
and so again, we do that here on the left hand side

85
00:04:43.033 --> 00:04:45.163
while we are doing destructuring.

86
00:04:48.390 --> 00:04:50.770
So let's take a look here at the main menu

87
00:04:53.120 --> 00:04:58.120
so, let's say that we want to take the pizza

88
00:04:58.650 --> 00:05:01.070
and the risotto, okay?

89
00:05:01.070 --> 00:05:03.710
So that's the first and the third

90
00:05:06.250 --> 00:05:09.920
so let's create a variable called pizza

91
00:05:09.920 --> 00:05:13.080
then we can skip one variable remember,

92
00:05:13.080 --> 00:05:17.010
so leaving a hole there in the destructuring assignment

93
00:05:17.010 --> 00:05:21.380
then let's call one variable risotto

94
00:05:21.380 --> 00:05:24.990
and then simply put all the other food well

95
00:05:24.990 --> 00:05:27.050
into an array called other food

96
00:05:28.000 --> 00:05:30.460
and now let's simply log everything here

97
00:05:30.460 --> 00:05:31.723
to the console,

98
00:05:39.910 --> 00:05:43.990
All right, so we get indeed the string pizza

99
00:05:43.990 --> 00:05:45.710
the string risotto

100
00:05:45.710 --> 00:05:48.810
and then all the rest of the elements

101
00:05:48.810 --> 00:05:52.850
that we didn't select previously into their own variables

102
00:05:52.850 --> 00:05:56.130
and note here that the rest syntax collects

103
00:05:56.130 --> 00:05:59.680
all the array after the last variable.

104
00:05:59.680 --> 00:06:02.090
So in this case here risotto

105
00:06:03.200 --> 00:06:06.570
so it does not include any skipped elements

106
00:06:06.570 --> 00:06:09.180
so it's really just the rest of the elements

107
00:06:09.180 --> 00:06:11.780
and yeah again, as I said,

108
00:06:11.780 --> 00:06:15.100
it does not include any skipped elements

109
00:06:15.100 --> 00:06:16.990
and so for that reason,

110
00:06:16.990 --> 00:06:19.890
the rest pattern always must be the lest

111
00:06:19.890 --> 00:06:21.860
in the destructuring assignment

112
00:06:21.860 --> 00:06:24.610
because otherwise how will JavaScript know

113
00:06:24.610 --> 00:06:29.610
until when it should collect the rest of the array, right?

114
00:06:29.690 --> 00:06:32.620
So for example, we could not do this

115
00:06:34.920 --> 00:06:37.970
so the error message is actually very explicit

116
00:06:37.970 --> 00:06:41.593
so the rest element must be the last element.

117
00:06:43.540 --> 00:06:46.650
All right, and also for the same reason

118
00:06:46.650 --> 00:06:49.515
there can only ever be one rest

119
00:06:49.515 --> 00:06:54.210
in any destructuring assignment, okay

120
00:06:55.350 --> 00:06:57.970
and now let's do the same in objects

121
00:06:57.970 --> 00:07:02.480
because it also works indeed in objects.

122
00:07:02.480 --> 00:07:04.190
So the difference then of course,

123
00:07:04.190 --> 00:07:06.830
is that the remaining elements will be collected

124
00:07:06.830 --> 00:07:10.870
into a new object and not into a new array.

125
00:07:10.870 --> 00:07:14.500
So let's not work here with our opening hours

126
00:07:14.500 --> 00:07:19.500
and let's say that we want to select only Saturday here

127
00:07:20.150 --> 00:07:23.410
and then the rest should go into a new object

128
00:07:23.410 --> 00:07:25.780
which are the weekdays.

129
00:07:25.780 --> 00:07:27.580
So Saturday is weekend

130
00:07:27.580 --> 00:07:31.740
and Friday and Thursday are the weekdays

131
00:07:31.740 --> 00:07:35.150
and so basically we want to create an object

132
00:07:35.150 --> 00:07:36.970
only with these two.

133
00:07:36.970 --> 00:07:41.970
So only for the week days and now that is easy to do

134
00:07:42.340 --> 00:07:47.070
all we need to do is to basically take out a Saturday

135
00:07:47.070 --> 00:07:48.770
into its own variable

136
00:07:48.770 --> 00:07:53.060
and then we simply collect the rest into a new object

137
00:07:53.060 --> 00:07:57.923
and this we can call weekdays, okay?

138
00:07:58.820 --> 00:08:01.090
And then here, of course the object

139
00:08:01.090 --> 00:08:05.300
that we are, destructuring dot opening hours

140
00:08:05.300 --> 00:08:09.220
and now let's take a look at our weekdays here

141
00:08:10.700 --> 00:08:14.110
and indeed it is exactly what we were expecting.

142
00:08:14.110 --> 00:08:17.690
It is an object only containing Friday and Thursday

143
00:08:18.550 --> 00:08:21.670
and again, that's because we already took Saturday

144
00:08:21.670 --> 00:08:24.160
into its own variable before

145
00:08:24.160 --> 00:08:26.985
and so this then collected the rest of the properties

146
00:08:26.985 --> 00:08:30.070
into its own new object.

147
00:08:30.070 --> 00:08:33.200
Great, so now we know how the rest pattern

148
00:08:33.200 --> 00:08:37.620
works to collect elements in a destructuring assignment

149
00:08:39.220 --> 00:08:41.493
and actually let's write that here.

150
00:08:43.190 --> 00:08:45.910
So this whole first part is for destructuring

151
00:08:50.690 --> 00:08:55.690
and then the second part will be about functions basically.

152
00:08:59.510 --> 00:09:03.230
So, remember that also for the spread operator

153
00:09:03.230 --> 00:09:06.720
the second use case was to pass multiple arguments

154
00:09:06.720 --> 00:09:09.560
into a function all at the same time.

155
00:09:09.560 --> 00:09:11.680
So that's exactly what we did here

156
00:09:11.680 --> 00:09:16.410
in our real example, with this ingredients array, right?

157
00:09:16.410 --> 00:09:17.660
So we had an array

158
00:09:17.660 --> 00:09:21.250
and then we expanded all of these elements of the array

159
00:09:21.250 --> 00:09:23.650
to basically pass these elements then

160
00:09:23.650 --> 00:09:26.980
as individual arguments of the function

161
00:09:29.010 --> 00:09:30.416
and so now, as you can guess

162
00:09:30.416 --> 00:09:33.910
the rest operator can basically do the opposite

163
00:09:34.820 --> 00:09:38.563
and so let's now write an example, function for debt.

164
00:09:39.820 --> 00:09:42.730
So I'm gonna call it add

165
00:09:42.730 --> 00:09:44.960
and so in a real adding function

166
00:09:44.960 --> 00:09:48.040
we wanna take an arbitrary amount of arguments

167
00:09:48.040 --> 00:09:50.903
and simply add all of them together, right?

168
00:09:52.280 --> 00:09:56.440
So function and for now, let's just leave it like this

169
00:09:58.620 --> 00:10:00.480
and so let me illustrate

170
00:10:00.480 --> 00:10:03.170
how we want to call this function, actually.

171
00:10:03.170 --> 00:10:05.790
So we want to be able to do for example,

172
00:10:05.790 --> 00:10:09.924
this two and three, it would give us five

173
00:10:09.924 --> 00:10:13.830
but then we also might want to be able to do this

174
00:10:13.830 --> 00:10:18.830
five and three and seven and two, for example.

175
00:10:19.500 --> 00:10:22.580
So again, any arbitrary amount of arguments

176
00:10:22.580 --> 00:10:24.200
should work for this function

177
00:10:26.130 --> 00:10:29.370
so something like this, for example,

178
00:10:29.370 --> 00:10:31.580
but of course we're not gonna specify

179
00:10:31.580 --> 00:10:34.740
like seven arguments here, right?

180
00:10:34.740 --> 00:10:36.860
So how can we do that?

181
00:10:36.860 --> 00:10:39.440
Well, we will use the rest pattern

182
00:10:40.310 --> 00:10:44.510
and in this case, it is actually called rest parameters.

183
00:10:44.510 --> 00:10:47.210
So let's use the rest syntax

184
00:10:47.210 --> 00:10:50.050
and then let's call this argument numbers

185
00:10:50.050 --> 00:10:55.050
and then log this numbers to the console.

186
00:10:55.680 --> 00:10:58.370
So this function is gonna be called three times

187
00:10:59.390 --> 00:11:02.770
and so we are expecting three results here

188
00:11:03.700 --> 00:11:06.870
and what we see here is three race

189
00:11:06.870 --> 00:11:10.390
with all the arguments that we passed into the functions

190
00:11:10.390 --> 00:11:12.490
but they are indeed a race

191
00:11:12.490 --> 00:11:15.570
and so now once again, as I said in the beginning

192
00:11:15.570 --> 00:11:19.020
the rest syntax is taking multiple numbers

193
00:11:19.020 --> 00:11:24.020
or multiple values and then packs them all into one array.

194
00:11:24.180 --> 00:11:26.120
So, once more it is doing the opposite

195
00:11:26.120 --> 00:11:28.100
of the spread operator

196
00:11:28.100 --> 00:11:30.292
so with the spread operator we expand

197
00:11:30.292 --> 00:11:33.690
with the rest syntax we compress

198
00:11:33.690 --> 00:11:37.400
so here it's called rest arguments, okay?

199
00:11:37.400 --> 00:11:39.810
And now we can write some simple logic here

200
00:11:39.810 --> 00:11:42.450
to actually add all the numbers together.

201
00:11:42.450 --> 00:11:44.360
I believe we already did that.

202
00:11:44.360 --> 00:11:49.060
So here is our sum variable that's gonna be accumulating

203
00:11:49.060 --> 00:11:51.990
then let's write a simple for loop

204
00:11:51.990 --> 00:11:54.180
and you could also do this year as a challenge

205
00:11:54.180 --> 00:11:55.460
if you want it

206
00:11:55.460 --> 00:11:57.713
but anyway, I will just do it right away.

207
00:11:59.090 --> 00:12:01.769
So we know that numbers is an array

208
00:12:01.769 --> 00:12:05.290
and so we can take the length of that array

209
00:12:05.290 --> 00:12:06.780
and run this loop

210
00:12:06.780 --> 00:12:10.480
as long as the counter is below the length of the array

211
00:12:10.480 --> 00:12:15.480
and in each iteration we simply add the current number

212
00:12:16.350 --> 00:12:21.350
to the current sum value basically.

213
00:12:21.630 --> 00:12:23.140
So I'm writing this really fast

214
00:12:23.140 --> 00:12:26.900
because we already did this before, all right?

215
00:12:26.900 --> 00:12:29.980
And so this should be nothing new at this point

216
00:12:29.980 --> 00:12:33.770
and now to finish we can log this sum to the console

217
00:12:33.770 --> 00:12:35.270
to get some results

218
00:12:35.270 --> 00:12:38.060
and indeed this year is now five

219
00:12:39.110 --> 00:12:42.460
and so this is at this point a working function

220
00:12:42.460 --> 00:12:46.310
which can accept any number of parameters

221
00:12:46.310 --> 00:12:50.230
and hopefully your not confused yet by this

222
00:12:51.340 --> 00:12:55.020
and now I want to take it even to the next level.

223
00:12:55.020 --> 00:12:58.970
So let's create yet another array let's just call it X

224
00:12:58.970 --> 00:13:00.456
because it's not important

225
00:13:00.456 --> 00:13:05.456
and I will put in numbers 23 and let's say five and seven.

226
00:13:08.020 --> 00:13:11.350
So now if we wanted to take these values here

227
00:13:11.350 --> 00:13:12.920
and call the add function

228
00:13:12.920 --> 00:13:16.810
with these three values, how would we do that?

229
00:13:16.810 --> 00:13:18.640
Well, simply enough

230
00:13:18.640 --> 00:13:22.567
we simply use the spread operator and that's it

231
00:13:22.567 --> 00:13:25.090
and so this is exactly what we learned

232
00:13:25.090 --> 00:13:27.090
in the previous lecture.

233
00:13:27.090 --> 00:13:29.660
So we're taking all the numbers of the array

234
00:13:29.660 --> 00:13:31.200
and spreading them here

235
00:13:31.200 --> 00:13:33.860
and so this would be the same as writing manually

236
00:13:33.860 --> 00:13:36.630
23, five and seven

237
00:13:36.630 --> 00:13:38.520
and so this is a good example of showing you

238
00:13:38.520 --> 00:13:41.700
how spread is the opposite of rest

239
00:13:41.700 --> 00:13:44.890
because after these numbers being spread here

240
00:13:44.890 --> 00:13:48.280
they will then enter this add function here

241
00:13:48.280 --> 00:13:51.300
and then they will immediately be collected

242
00:13:51.300 --> 00:13:56.200
into this numbers array by the rest parameters, okay?

243
00:13:56.200 --> 00:13:58.267
So here we unpacked the values

244
00:13:58.267 --> 00:14:01.750
and here pack them back again into an array

245
00:14:02.700 --> 00:14:04.780
and you could actually be wondering

246
00:14:04.780 --> 00:14:08.260
why we are not simply writing an add function

247
00:14:08.260 --> 00:14:10.890
which takes an array as an argument

248
00:14:10.890 --> 00:14:13.300
and then we don't need all of this.

249
00:14:13.300 --> 00:14:15.970
Well, it's way better to do it like this

250
00:14:15.970 --> 00:14:19.420
because then the function can accept both an array

251
00:14:19.420 --> 00:14:21.300
basically by doing this

252
00:14:21.300 --> 00:14:25.330
and simply all the single values like this

253
00:14:25.330 --> 00:14:28.100
and also it feels a little bit more natural

254
00:14:28.100 --> 00:14:32.410
to simply pass as many arguments as we want to add together

255
00:14:32.410 --> 00:14:33.770
into the function.

256
00:14:33.770 --> 00:14:38.050
So without having to deal with arrays if we don't want to

257
00:14:38.050 --> 00:14:41.440
and so this rest parameters is something

258
00:14:41.440 --> 00:14:42.996
that you will see all the time

259
00:14:42.996 --> 00:14:46.210
in modern JavaScript code basis.

260
00:14:46.210 --> 00:14:48.470
Okay, and now just to finish this

261
00:14:48.470 --> 00:14:50.990
let's actually use rest parameters

262
00:14:50.990 --> 00:14:55.990
in our restaurant example here also to see some edge cases.

263
00:14:56.810 --> 00:14:59.965
So let's add yet another method here

264
00:14:59.965 --> 00:15:04.513
and this time to method is gonna be about ordering pizza.

265
00:15:05.570 --> 00:15:08.620
So order pizza

266
00:15:10.390 --> 00:15:14.780
and now pizzas need to have at least one ingredient

267
00:15:14.780 --> 00:15:17.640
but the other ingredients are optional

268
00:15:17.640 --> 00:15:21.530
and for this rest parameters are perfect.

269
00:15:21.530 --> 00:15:26.530
So let's say main ingredient and then the other ingredients

270
00:15:31.430 --> 00:15:34.220
and then this is gonna work a little bit

271
00:15:34.220 --> 00:15:36.946
like destructuring again where

272
00:15:36.946 --> 00:15:40.310
this here basically we'll collect all of the rest

273
00:15:40.310 --> 00:15:43.210
of the arguments into an array.

274
00:15:43.210 --> 00:15:47.390
So let's see that so main ingredient

275
00:15:48.670 --> 00:15:52.383
and that's logged the other ingredients, okay?

276
00:15:54.950 --> 00:15:56.660
And so now let's order pizza

277
00:16:03.100 --> 00:16:06.620
so restaurants thought order pizza

278
00:16:06.620 --> 00:16:09.770
and now here we specify our ingredients.

279
00:16:09.770 --> 00:16:14.770
So let's say mushrooms, onion, olives and spinach

280
00:16:18.400 --> 00:16:20.780
so a nice vegetarian pizza right here

281
00:16:22.240 --> 00:16:25.300
and so you see we can specify as many arguments

282
00:16:25.300 --> 00:16:29.460
as we want it, let's save this

283
00:16:29.460 --> 00:16:31.320
and do you see down here immediately

284
00:16:31.320 --> 00:16:35.810
that we get mushrooms, which is this first ingredient here

285
00:16:35.810 --> 00:16:37.210
and then we get an array

286
00:16:37.210 --> 00:16:41.510
of all the remaining ingredients that we passed in

287
00:16:41.510 --> 00:16:45.890
and so this of course is the result of the rest arguments.

288
00:16:45.890 --> 00:16:49.340
So, again the first argument was stored

289
00:16:49.340 --> 00:16:53.730
into this main argument here

290
00:16:53.730 --> 00:16:56.350
and then all the remaining arguments that were passed

291
00:16:56.350 --> 00:16:59.750
in were simply stored into this array

292
00:16:59.750 --> 00:17:04.210
by the rest parameter of syntax, okay?

293
00:17:04.210 --> 00:17:07.773
And of course we could also simply define just one.

294
00:17:09.460 --> 00:17:14.460
So let's order now a pizza with only mushrooms

295
00:17:16.230 --> 00:17:21.230
then the remaining arguments here will simply be put

296
00:17:21.390 --> 00:17:25.360
in an empty array because of course there are none

297
00:17:25.360 --> 00:17:28.640
and so there is nothing to collect into the array

298
00:17:28.640 --> 00:17:30.718
but we still get an empty array

299
00:17:30.718 --> 00:17:33.800
that we can work with if we want.

300
00:17:33.800 --> 00:17:36.289
So in that function, we could now create some logic

301
00:17:36.289 --> 00:17:40.770
like to create a string based on all of these ingredients.

302
00:17:40.770 --> 00:17:43.459
But I am not gonna go into that right now

303
00:17:43.459 --> 00:17:45.480
but if you wanna have some fun

304
00:17:45.480 --> 00:17:49.033
then feel of course free to do that by yourself.

305
00:17:50.730 --> 00:17:53.940
Anyway the take away from this example is that

306
00:17:53.940 --> 00:17:57.710
once again the rest parameters serves to collect

307
00:17:57.710 --> 00:18:01.650
all of the remaining basically unused parameters

308
00:18:01.650 --> 00:18:05.853
that were not used in this parameter.

309
00:18:08.950 --> 00:18:11.100
All right, so let's recap

310
00:18:11.100 --> 00:18:15.470
after yet another quiet, long lecture here.

311
00:18:15.470 --> 00:18:18.000
So, the spread and rests syntax

312
00:18:18.000 --> 00:18:20.150
both look exactly the same

313
00:18:20.150 --> 00:18:22.560
but they work in opposite ways

314
00:18:22.560 --> 00:18:25.860
depending on where they are used.

315
00:18:25.860 --> 00:18:28.120
So the spread operator is used

316
00:18:28.120 --> 00:18:32.940
where we would otherwise write values, separated by a comma.

317
00:18:32.940 --> 00:18:36.490
On the other hand the rest pattern is basically used

318
00:18:36.490 --> 00:18:39.960
where we would otherwise write variable names

319
00:18:39.960 --> 00:18:41.713
separated by commas.

320
00:18:42.700 --> 00:18:45.460
So, again the rest pattern can be used

321
00:18:45.460 --> 00:18:49.600
where we would write variable names, separated by commas

322
00:18:49.600 --> 00:18:52.830
and not values separated by commas.

323
00:18:52.830 --> 00:18:56.210
So it's a subtle distinction, but this is how you know

324
00:18:56.210 --> 00:18:59.393
when and where to use spread and rest.

