WEBVTT

1
00:00:01.180 --> 00:00:05.360
<v ->Let's now talk about the amazing spread operator.</v>

2
00:00:05.360 --> 00:00:07.540
So we can use the spread operator

3
00:00:07.540 --> 00:00:12.080
to basically expand an array into all its elements.

4
00:00:12.080 --> 00:00:15.943
So basically unpacking all the array elements at one.

5
00:00:17.720 --> 00:00:19.733
So let's say that we have an array,

6
00:00:22.010 --> 00:00:24.770
so seven, eight, nine.

7
00:00:24.770 --> 00:00:29.140
And now we want to create a new array based one this array

8
00:00:29.140 --> 00:00:31.770
but with some new elements at the beginning.

9
00:00:31.770 --> 00:00:33.900
So how would we do that?

10
00:00:33.900 --> 00:00:36.050
Well, with what we already know,

11
00:00:36.050 --> 00:00:38.870
we would need to loop over this array,

12
00:00:38.870 --> 00:00:41.523
or even worse, do it manually.

13
00:00:42.540 --> 00:00:44.920
For example, like this.

14
00:00:44.920 --> 00:00:48.593
Let's call it the Bad New Array.

15
00:00:49.560 --> 00:00:52.380
So if we wanted to add one and two

16
00:00:52.380 --> 00:00:54.000
to the beginning of this array,

17
00:00:54.000 --> 00:00:56.920
we would have to write one, two,

18
00:00:56.920 --> 00:00:59.473
and then each of these elements.

19
00:01:00.970 --> 00:01:03.653
So that would be arr. 0,

20
00:01:05.585 --> 00:01:06.543
arr. 1,

21
00:01:09.250 --> 00:01:10.543
and arr. 2.

22
00:01:15.670 --> 00:01:18.420
Okay, let's take a look.

23
00:01:18.420 --> 00:01:20.430
And now we need to get a new array

24
00:01:20.430 --> 00:01:22.630
with the three original elements

25
00:01:22.630 --> 00:01:26.320
and then a one, two at the beginning of that array.

26
00:01:26.320 --> 00:01:28.510
Okay, and this is actually quite

27
00:01:28.510 --> 00:01:31.110
a common operation that we need to do

28
00:01:31.110 --> 00:01:33.800
and so we can now, since ES6,

29
00:01:33.800 --> 00:01:35.600
do it in a much better way

30
00:01:35.600 --> 00:01:38.120
using the spread operator.

31
00:01:38.120 --> 00:01:39.620
So with the spread operator,

32
00:01:39.620 --> 00:01:41.393
it's gonna work like this.

33
00:01:42.530 --> 00:01:44.023
So let's create a new array.

34
00:01:45.050 --> 00:01:48.803
So this is the good, let's say New Array.

35
00:01:50.080 --> 00:01:53.640
And then, again, we use one, two,

36
00:01:53.640 --> 00:01:55.670
and then we use the spread operator,

37
00:01:55.670 --> 00:01:57.540
which is dot dot dot,

38
00:01:57.540 --> 00:01:59.710
to basically expand this array

39
00:01:59.710 --> 00:02:02.890
into all of its individual elements.

40
00:02:02.890 --> 00:02:04.150
So let's see the result,

41
00:02:04.150 --> 00:02:06.693
and then I will explain it a little bit better.

42
00:02:07.950 --> 00:02:11.490
So new array, and you see that we get

43
00:02:11.490 --> 00:02:14.180
the exact same result here.

44
00:02:14.180 --> 00:02:16.270
So what the spread operator does

45
00:02:16.270 --> 00:02:18.350
is to basically take all the values

46
00:02:18.350 --> 00:02:20.800
out of this arr. array,

47
00:02:20.800 --> 00:02:22.790
and then write them individually

48
00:02:22.790 --> 00:02:27.040
as if we wrote seven, eight, nine here manually.

49
00:02:27.040 --> 00:02:31.630
All right, so if we wrote it without these three dots,

50
00:02:31.630 --> 00:02:33.530
then we would have this array,

51
00:02:34.634 --> 00:02:37.801
so this arr. array inside of this one.

52
00:02:39.070 --> 00:02:40.490
So just like this.

53
00:02:40.490 --> 00:02:43.920
So one, two, and then an array of seven, eight, nine.

54
00:02:43.920 --> 00:02:46.030
And that's because here, we are including

55
00:02:46.030 --> 00:02:47.730
this entire array.

56
00:02:47.730 --> 00:02:50.330
But with the spread operator, again,

57
00:02:50.330 --> 00:02:53.680
it's like taking all the elements out of the array

58
00:02:53.680 --> 00:02:55.970
and writing them here manually.

59
00:02:55.970 --> 00:02:57.600
And so when we do this,

60
00:02:57.600 --> 00:02:59.140
we then get seven, eight, nine,

61
00:02:59.140 --> 00:03:03.330
individually here, represented in this new array.

62
00:03:03.330 --> 00:03:07.190
So what this means is that we can use the spread operator

63
00:03:07.190 --> 00:03:09.480
whenever we would otherwise write

64
00:03:09.480 --> 00:03:12.630
multiple values separated by commas.

65
00:03:12.630 --> 00:03:14.400
And that situation happens

66
00:03:14.400 --> 00:03:16.810
whenever we write an array literal

67
00:03:16.810 --> 00:03:18.833
like we did up here.

68
00:03:20.190 --> 00:03:22.350
So that's the first situation in which

69
00:03:22.350 --> 00:03:25.770
it's very useful to expand an array.

70
00:03:25.770 --> 00:03:27.590
And the second situation is

71
00:03:27.590 --> 00:03:31.000
when we pass arguments into functions.

72
00:03:31.000 --> 00:03:33.920
So, for example, let's say

73
00:03:33.920 --> 00:03:37.600
that we wanted to actually log the individual elements

74
00:03:37.600 --> 00:03:39.403
of this new array here.

75
00:03:40.630 --> 00:03:42.630
So if we simply logged the array,

76
00:03:42.630 --> 00:03:44.860
then it's, of course, gonna look like this.

77
00:03:44.860 --> 00:03:47.910
It's just one value with just the array,

78
00:03:47.910 --> 00:03:50.330
it's just one big value.

79
00:03:50.330 --> 00:03:53.580
But if we use the spread operator

80
00:03:53.580 --> 00:03:55.683
to expand the new array,

81
00:03:56.750 --> 00:03:59.070
then see what happens then.

82
00:03:59.070 --> 00:04:03.070
So now it logged the individual elements of the array.

83
00:04:03.070 --> 00:04:05.560
So this would be the same as writing

84
00:04:05.560 --> 00:04:10.560
one, two, seven, eight, nine individually.

85
00:04:10.600 --> 00:04:13.140
So once again, whenever we need the elements

86
00:04:13.140 --> 00:04:14.940
of an array individually,

87
00:04:14.940 --> 00:04:16.900
then we can use the spread operator.

88
00:04:16.900 --> 00:04:19.840
And that is useful when we write an array

89
00:04:19.840 --> 00:04:22.360
and when we need to pass multiple elements

90
00:04:22.360 --> 00:04:25.540
into a function like we did here.

91
00:04:25.540 --> 00:04:30.030
All right, so let's see a bit more useful example.

92
00:04:30.030 --> 00:04:33.060
So in this example, we will create an array

93
00:04:33.060 --> 00:04:37.440
with one more food item in the main menu array.

94
00:04:37.440 --> 00:04:42.440
So that main menu is here at restaurant dot main menu,

95
00:04:43.640 --> 00:04:46.723
and so basically we want to create a new menu here.

96
00:04:47.750 --> 00:04:52.750
So const, new menu, and then let's say

97
00:04:54.230 --> 00:04:56.150
that we want the original array

98
00:04:56.150 --> 00:04:58.830
plus one new element.

99
00:04:58.830 --> 00:05:02.343
So we can do that by simply expanding the array,

100
00:05:03.710 --> 00:05:07.360
so that's restaurant dot main menu,

101
00:05:07.360 --> 00:05:09.590
and then we can add other stuff.

102
00:05:09.590 --> 00:05:12.216
So let's say gnocci,

103
00:05:12.216 --> 00:05:15.530
at least that's how I think it's spelled

104
00:05:15.530 --> 00:05:17.833
or pronounced in Italian.

105
00:05:18.780 --> 00:05:22.803
And so let's have a look at our new menu,

106
00:05:23.970 --> 00:05:27.010
and indeed, it has the three original elements,

107
00:05:27.010 --> 00:05:29.450
plus the gnocci.

108
00:05:29.450 --> 00:05:32.440
And keep in mind that here, we are indeed

109
00:05:32.440 --> 00:05:35.600
creating a completely new array, all right?

110
00:05:35.600 --> 00:05:37.470
We are, of course, not manipulating

111
00:05:37.470 --> 00:05:41.060
the restaurant dot main menu array.

112
00:05:41.060 --> 00:05:43.540
So we are building a new array from scratch,

113
00:05:43.540 --> 00:05:46.780
and you can see that here by the square brackets.

114
00:05:46.780 --> 00:05:50.110
So this brackets syntax here is simply the way

115
00:05:50.110 --> 00:05:53.470
in which we have always been writing new arrays.

116
00:05:53.470 --> 00:05:56.150
And so here, again, we are writing a new array

117
00:05:56.150 --> 00:05:59.820
but simply based on expanding this array,

118
00:05:59.820 --> 00:06:02.083
and then adding another element to it.

119
00:06:04.150 --> 00:06:05.640
Okay.

120
00:06:05.640 --> 00:06:09.110
Now you might have noticed that the spread operator

121
00:06:09.110 --> 00:06:12.140
is actually a bit similar to destructuring,

122
00:06:12.140 --> 00:06:16.262
because it also helps us get elements out of arrays.

123
00:06:16.262 --> 00:06:20.140
Now, the big difference is that the spread operator

124
00:06:20.140 --> 00:06:22.610
takes all the elements from the array

125
00:06:22.610 --> 00:06:25.590
and it also doesn't create new variables.

126
00:06:25.590 --> 00:06:28.230
And as a consequence, we can only use it

127
00:06:28.230 --> 00:06:30.810
in places where we would otherwise

128
00:06:30.810 --> 00:06:33.093
write values separated by commas.

129
00:06:33.930 --> 00:06:35.740
And, in case you're taking notes,

130
00:06:35.740 --> 00:06:39.240
probably what I just said would be very helpful

131
00:06:39.240 --> 00:06:40.843
to have as a note.

132
00:06:42.230 --> 00:06:45.640
Next, let's learn about two important use cases

133
00:06:45.640 --> 00:06:47.400
of the spread operator,

134
00:06:47.400 --> 00:06:50.550
which is to create shallow copies of arrays,

135
00:06:50.550 --> 00:06:52.723
and to merge two arrays together.

136
00:06:55.640 --> 00:06:57.390
So let's say copy array,

137
00:06:57.390 --> 00:07:01.270
and so let's simply create a copy of the main menu.

138
00:07:01.270 --> 00:07:06.270
So main menu copy, and so let's write a new array,

139
00:07:07.520 --> 00:07:10.490
and into that new array, we will put all the elements

140
00:07:10.490 --> 00:07:13.003
that are currently in the main menu.

141
00:07:14.760 --> 00:07:19.760
So at restaurant dot main menu, and that's it.

142
00:07:19.890 --> 00:07:24.180
So here we just created a shallow copy of this array.

143
00:07:24.180 --> 00:07:27.400
So that's a little bit similar to object dot assign

144
00:07:27.400 --> 00:07:30.350
that we used in the previous section, okay?

145
00:07:30.350 --> 00:07:34.750
But here, this syntax is actually a lot easier to use.

146
00:07:34.750 --> 00:07:36.803
Now to join two arrays together,

147
00:07:38.040 --> 00:07:41.560
so join two arrays or more, of course,

148
00:07:41.560 --> 00:07:43.910
we can use the same technique.

149
00:07:43.910 --> 00:07:46.110
And so maybe, at this point, you can already guess

150
00:07:46.110 --> 00:07:47.771
how that would work, and so

151
00:07:47.771 --> 00:07:50.480
you can do this, actually, as a challenge.

152
00:07:50.480 --> 00:07:52.090
So pause the video right now,

153
00:07:52.090 --> 00:07:57.090
and create this variable menu which will be an array

154
00:07:57.920 --> 00:07:59.670
which contains the whole menu.

155
00:07:59.670 --> 00:08:02.850
So both the main menu and the starter menu.

156
00:08:02.850 --> 00:08:05.100
So take a minute and try it on your own here.

157
00:08:06.980 --> 00:08:10.260
All right, so hopefully, you managed to do that.

158
00:08:10.260 --> 00:08:11.950
And so the secret here, again,

159
00:08:11.950 --> 00:08:13.993
is to use the spread operator.

160
00:08:15.530 --> 00:08:20.530
So restaurant, and let's start with the starter menu.

161
00:08:20.610 --> 00:08:23.680
So that's gonna be our first couple of elements

162
00:08:23.680 --> 00:08:26.700
in this new array, and then, of course,

163
00:08:26.700 --> 00:08:29.290
we can use the spread operator again,

164
00:08:29.290 --> 00:08:32.403
and then this time expand the main menu.

165
00:08:34.550 --> 00:08:36.373
Dot main menu.

166
00:08:38.430 --> 00:08:40.460
And so now we end up with an array

167
00:08:40.460 --> 00:08:43.320
containing all the food items that are both

168
00:08:43.320 --> 00:08:45.770
in the starter and the main menu.

169
00:08:45.770 --> 00:08:48.800
And again, because here, with this spread operator,

170
00:08:48.800 --> 00:08:51.406
we took all the elements out of the starter menu

171
00:08:51.406 --> 00:08:54.866
and basically wrote them here into this new array,

172
00:08:54.866 --> 00:08:58.053
and then the same with the main menu.

173
00:08:59.010 --> 00:09:02.200
All right, so I told you that the spread operator

174
00:09:02.200 --> 00:09:05.960
works on arrays, but that's not entirely true,

175
00:09:05.960 --> 00:09:08.280
because actually, the spread operator

176
00:09:08.280 --> 00:09:11.610
works on all so-called iterables.

177
00:09:11.610 --> 00:09:13.800
Now what is an iterable?

178
00:09:13.800 --> 00:09:17.320
Well, there are different iterables in JavaScript.

179
00:09:17.320 --> 00:09:19.200
And we will talk about all of them

180
00:09:19.200 --> 00:09:20.830
by the end of the course,

181
00:09:20.830 --> 00:09:23.160
but for now, just know that iterables

182
00:09:23.160 --> 00:09:28.160
are things like all arrays, strings, maps, or sets,

183
00:09:28.680 --> 00:09:30.600
but not objects.

184
00:09:30.600 --> 00:09:33.280
So basically, most of the built-in data structures

185
00:09:33.280 --> 00:09:38.280
in JavaScript are now iterables, but except objects.

186
00:09:38.340 --> 00:09:40.490
So let me actually write that here for you.

187
00:09:41.330 --> 00:09:46.330
Iterables are arrays, strings, maps, and sets,

188
00:09:50.310 --> 00:09:53.300
but not objects.

189
00:09:53.300 --> 00:09:57.160
Now anyway, since strings are also iterables,

190
00:09:57.160 --> 00:09:59.620
that means that we can use the spread operator

191
00:09:59.620 --> 00:10:00.993
on a string, as well.

192
00:10:02.450 --> 00:10:04.313
So let me quickly show that to you.

193
00:10:05.470 --> 00:10:10.003
So let's just create a quick string here, Jonas,

194
00:10:10.950 --> 00:10:13.180
and then I want to create an array

195
00:10:13.180 --> 00:10:16.000
which contains all the individual letters,

196
00:10:16.000 --> 00:10:18.030
plus some other elements.

197
00:10:18.030 --> 00:10:21.693
So, let's call this one letters,

198
00:10:23.200 --> 00:10:25.490
and then we create a new array

199
00:10:25.490 --> 00:10:28.223
and expand the string here as well.

200
00:10:29.760 --> 00:10:32.100
Then here I want an empty string,

201
00:10:32.100 --> 00:10:34.223
then here I want an S,

202
00:10:36.220 --> 00:10:39.360
and then let's log it through console,

203
00:10:39.360 --> 00:10:42.383
and tnow it will make a little bit more sense.

204
00:10:43.710 --> 00:10:47.610
All right, and so indeed, here we get this array,

205
00:10:47.610 --> 00:10:50.160
where each letter of the original string

206
00:10:50.160 --> 00:10:52.800
is now an individual element.

207
00:10:52.800 --> 00:10:56.790
So just like we expanded, so we unpacked an array,

208
00:10:56.790 --> 00:10:59.570
we now did the same thing with a string.

209
00:10:59.570 --> 00:11:01.090
Now just keep in mind

210
00:11:01.090 --> 00:11:03.840
that we can still only use the spread operator

211
00:11:03.840 --> 00:11:05.470
when building an array,

212
00:11:05.470 --> 00:11:09.300
or when we pass values into a function.

213
00:11:09.300 --> 00:11:12.853
So for example, we can also do this.

214
00:11:15.070 --> 00:11:17.520
So expand the string here,

215
00:11:17.520 --> 00:11:20.673
and so then it is the same thing as writing this.

216
00:11:23.070 --> 00:11:27.563
So J, O, and so on and so forth, right?

217
00:11:28.800 --> 00:11:32.653
So, indeed, here now we get all the individual elements.

218
00:11:33.570 --> 00:11:36.530
All right, so for example, what we can't do

219
00:11:36.530 --> 00:11:40.643
is to use this to build a string using a template literal.

220
00:11:44.470 --> 00:11:48.053
So here, this is not gonna work.

221
00:11:49.060 --> 00:11:51.440
And that's because this is not a place

222
00:11:51.440 --> 00:11:55.143
that expects multiple values separated by a comma.

223
00:11:56.650 --> 00:12:00.890
So you see unexpected token, all right?

224
00:12:00.890 --> 00:12:04.640
So again, multiple values separated by a comma

225
00:12:04.640 --> 00:12:06.670
are usually only expected

226
00:12:06.670 --> 00:12:09.160
when we pass arguments into a function,

227
00:12:09.160 --> 00:12:11.510
or when we build a new array.

228
00:12:11.510 --> 00:12:12.950
So take note of that,

229
00:12:12.950 --> 00:12:15.360
because that is important to understand

230
00:12:15.360 --> 00:12:17.600
about the spread operator.

231
00:12:17.600 --> 00:12:21.370
Okay, but now enough with building arrays.

232
00:12:21.370 --> 00:12:23.740
Let's now actually write our own function

233
00:12:23.740 --> 00:12:25.970
that accepts multiple arguments

234
00:12:25.970 --> 00:12:27.730
and then use the spread operator

235
00:12:27.730 --> 00:12:30.230
to actually pass those arguments.

236
00:12:30.230 --> 00:12:34.630
And so that's gonna be a very real-life example right there.

237
00:12:34.630 --> 00:12:37.752
So let's add here another method now,

238
00:12:37.752 --> 00:12:40.410
and so, let's say that we want a method

239
00:12:40.410 --> 00:12:43.090
to order just pasta, okay?

240
00:12:43.090 --> 00:12:45.300
And the pasta always needs to have

241
00:12:45.300 --> 00:12:47.363
exactly three ingredients.

242
00:12:48.300 --> 00:12:53.300
So let's say order pasta, and it's gonna be a function,

243
00:12:54.770 --> 00:12:57.453
and so now here, we need three ingredients.

244
00:12:58.510 --> 00:13:03.033
So let's just call them ing. 1, ing. 2, and ing. 3.

245
00:13:04.770 --> 00:13:09.310
And then just log them to the console, some string,

246
00:13:09.310 --> 00:13:13.720
here is your delicious pasta

247
00:13:15.128 --> 00:13:17.423
with ing. 1,

248
00:13:19.630 --> 00:13:21.290
ing. 2,

249
00:13:21.290 --> 00:13:25.450
and ing. 3.

250
00:13:25.450 --> 00:13:27.850
So up here, we have an error,

251
00:13:27.850 --> 00:13:30.143
so this should be number three.

252
00:13:32.390 --> 00:13:34.890
And then, let's now call this function.

253
00:13:34.890 --> 00:13:37.210
So order pasta.

254
00:13:37.210 --> 00:13:38.540
Now what I want to do here

255
00:13:38.540 --> 00:13:40.680
is to actually get these ingredients

256
00:13:40.680 --> 00:13:42.430
from a prompt window.

257
00:13:42.430 --> 00:13:45.380
So remember the prompt function that we can use,

258
00:13:45.380 --> 00:13:48.653
and so let's create an array called ingredients.

259
00:13:52.580 --> 00:13:55.060
And each element here will be defined

260
00:13:55.060 --> 00:13:56.363
by a prompt window.

261
00:13:58.010 --> 00:13:59.497
So this here now has nothing to do with

262
00:13:59.497 --> 00:14:00.990
the spread operator,

263
00:14:00.990 --> 00:14:03.200
it's just a way so that we can actually

264
00:14:03.200 --> 00:14:06.210
input the data ourselves.

265
00:14:06.210 --> 00:14:07.163
So let's say,

266
00:14:09.906 --> 00:14:12.033
and here we need to escape this,

267
00:14:12.870 --> 00:14:16.793
So let's make pasta.

268
00:14:18.150 --> 00:14:21.010
Ingredient one.

269
00:14:21.010 --> 00:14:24.700
And I think, I didn't show you this escaping here before.

270
00:14:24.700 --> 00:14:29.170
So here, when we simply write this single quote here,

271
00:14:29.170 --> 00:14:30.620
to write let's,

272
00:14:30.620 --> 00:14:34.800
JavaScript thinks that we are finishing this string here.

273
00:14:34.800 --> 00:14:38.040
Okay, and so we could use the double quotes out here

274
00:14:38.040 --> 00:14:42.680
or we can escape using the backslash, okay?

275
00:14:42.680 --> 00:14:44.970
Now when we save this, I think that Prettier

276
00:14:44.970 --> 00:14:47.400
will actually get rid of this here,

277
00:14:47.400 --> 00:14:51.240
but it's still important to know that escaping exists.

278
00:14:51.240 --> 00:14:54.730
So basically, this masks this single quote here,

279
00:14:54.730 --> 00:14:57.850
so that it does not finish the string at this point.

280
00:14:57.850 --> 00:14:58.733
So let's save it.

281
00:14:59.740 --> 00:15:02.770
And so you see that now, the Prettier extension

282
00:15:02.770 --> 00:15:06.530
actually replaced the single quote with the double quote.

283
00:15:06.530 --> 00:15:09.400
And so here we see our prompt already,

284
00:15:09.400 --> 00:15:11.053
but let's create two more.

285
00:15:15.360 --> 00:15:18.123
So let's say ingredient two now,

286
00:15:20.750 --> 00:15:22.360
and then another one.

287
00:15:22.360 --> 00:15:24.800
So again, here we are, simply building an array

288
00:15:24.800 --> 00:15:26.273
of the three ingredients.

289
00:15:29.280 --> 00:15:32.263
Okay, and then we can log it to the console,

290
00:15:33.180 --> 00:15:35.660
just to see A,

291
00:15:35.660 --> 00:15:36.913
B, and C.

292
00:15:38.390 --> 00:15:41.110
And so, indeed, we now get these array ingredients

293
00:15:41.110 --> 00:15:44.610
with A, B, and C, which are the three strings

294
00:15:44.610 --> 00:15:46.003
that we just wrote there.

295
00:15:47.220 --> 00:15:49.610
And now, how should we actually call

296
00:15:49.610 --> 00:15:51.373
the order pasta function?

297
00:15:53.060 --> 00:15:57.730
So restaurant dot order pasta.

298
00:15:57.730 --> 00:16:00.461
And in the old way, we would now write

299
00:16:00.461 --> 00:16:05.461
ingredients zero, ingredients one, and ingredients two.

300
00:16:11.170 --> 00:16:13.790
But, since we learned about the spread operator

301
00:16:13.790 --> 00:16:17.290
in this lecture, we can now do a lot better.

302
00:16:17.290 --> 00:16:20.630
And so, instead, we do this.

303
00:16:20.630 --> 00:16:23.543
Restaurant dot order pasta.

304
00:16:25.090 --> 00:16:28.170
And now, all we need to do is to expand

305
00:16:28.170 --> 00:16:30.890
the elements of the ingredient array,

306
00:16:30.890 --> 00:16:33.170
and that will then basically

307
00:16:33.170 --> 00:16:35.810
write the three elements of the array

308
00:16:35.810 --> 00:16:37.383
here separated by commas.

309
00:16:38.990 --> 00:16:42.910
So this and this should yield the exact same result,

310
00:16:42.910 --> 00:16:46.223
and so let's now test it out with some real data.

311
00:16:47.720 --> 00:16:52.720
So let's see, mushrooms, asparagus, and cheese.

312
00:16:54.600 --> 00:16:57.040
And so, in these, we get now twice,

313
00:16:57.040 --> 00:16:58.460
here is your delicious pasta

314
00:16:58.460 --> 00:17:02.160
with mushrooms, asparagus, and cheese.

315
00:17:02.160 --> 00:17:04.420
And what do you think is the better solution?

316
00:17:04.420 --> 00:17:07.030
This one, or this one?

317
00:17:07.030 --> 00:17:09.430
And especially considering that an array

318
00:17:09.430 --> 00:17:11.540
could, of course, be a lot longer

319
00:17:11.540 --> 00:17:13.420
than just three elements.

320
00:17:13.420 --> 00:17:15.268
So indeed, always go with this

321
00:17:15.268 --> 00:17:18.680
more modern ES6 syntax here.

322
00:17:18.680 --> 00:17:21.610
It's an amazing addition to the language.

323
00:17:21.610 --> 00:17:24.310
And now, just to finish this lecture here,

324
00:17:24.310 --> 00:17:27.490
since ES 2018, the spread operator

325
00:17:27.490 --> 00:17:30.360
actually also works on objects,

326
00:17:30.360 --> 00:17:32.937
even though objects are not iterables.

327
00:17:34.800 --> 00:17:36.573
So let's write that here.

328
00:17:37.740 --> 00:17:41.910
And here let's just write real-world example.

329
00:17:47.110 --> 00:17:49.253
And so let's now experiment with this.

330
00:17:50.100 --> 00:17:52.200
The first example here was to create

331
00:17:52.200 --> 00:17:56.860
a new array based on one initial array, right?

332
00:17:56.860 --> 00:18:00.220
And so let's now also create a new restaurant object

333
00:18:00.220 --> 00:18:02.540
with all the data from the original one

334
00:18:02.540 --> 00:18:04.493
plus some additional data.

335
00:18:05.610 --> 00:18:09.000
And so this is actually an amazing way of doing this,

336
00:18:09.000 --> 00:18:12.660
because it's so much easier than with old JavaScript.

337
00:18:12.660 --> 00:18:15.423
So let's call this one new restaurant.

338
00:18:18.460 --> 00:18:22.560
And then we can simply spread the old restaurant

339
00:18:22.560 --> 00:18:25.080
and this will then basically copy all the properties

340
00:18:25.080 --> 00:18:28.000
of the restaurant into this new object.

341
00:18:28.000 --> 00:18:30.690
And then we can add anything that we want.

342
00:18:30.690 --> 00:18:34.470
Founder, for example, let's say Giuseppe,

343
00:18:34.470 --> 00:18:38.620
Or Giuseppe, I don't really know how to say it.

344
00:18:38.620 --> 00:18:42.410
And, of course, here, the order does not matter as always.

345
00:18:42.410 --> 00:18:46.400
So this spread here doesn't even have to be the first one.

346
00:18:46.400 --> 00:18:50.320
So let's say we also want the founding year,

347
00:18:50.320 --> 00:18:51.963
let's say 1998,

348
00:18:53.143 --> 00:18:54.390
okay?

349
00:18:54.390 --> 00:18:56.963
And so with this, we created a brand new object.

350
00:18:57.840 --> 00:19:01.390
Now we need to get rid of these three prompts there,

351
00:19:01.390 --> 00:19:04.543
because otherwise, it's gonna drive us crazy.

352
00:19:06.320 --> 00:19:07.770
But let's just take this out,

353
00:19:11.130 --> 00:19:14.603
and simply log here the new restaurant to the console.

354
00:19:16.320 --> 00:19:20.890
And so indeed, we get our original object basically,

355
00:19:20.890 --> 00:19:23.773
plus the founder, and plus founded in.

356
00:19:24.640 --> 00:19:25.810
Great.

357
00:19:25.810 --> 00:19:27.960
And finally, since we were able to do

358
00:19:27.960 --> 00:19:32.290
shallow copies of arrays, using the spread operator,

359
00:19:32.290 --> 00:19:34.740
we can do the same with objects.

360
00:19:34.740 --> 00:19:37.150
So instead of using object dot assign,

361
00:19:37.150 --> 00:19:39.423
as we did it in the previous lecture.

362
00:19:40.260 --> 00:19:41.403
So let's do that.

363
00:19:42.450 --> 00:19:45.173
Restaurant copy.

364
00:19:46.140 --> 00:19:50.220
And so all we need to do is an empty object

365
00:19:50.220 --> 00:19:52.680
and then in there expand all the elements

366
00:19:52.680 --> 00:19:57.300
of the original object, so the restaurant, in this case.

367
00:19:57.300 --> 00:20:00.553
And so now, if we attempt to change something on the copy,

368
00:20:02.130 --> 00:20:05.990
copy dot name,

369
00:20:05.990 --> 00:20:09.833
let's call it now Ristorante Roma,

370
00:20:12.950 --> 00:20:13.850
and if you're Italian,

371
00:20:13.850 --> 00:20:16.143
you're not gonna like how that sounds.

372
00:20:17.140 --> 00:20:22.040
But anyway, now, as we take a look at both of them,

373
00:20:22.040 --> 00:20:26.363
so the name of the copy and the original,

374
00:20:27.480 --> 00:20:29.653
now you will see that they are different.

375
00:20:31.800 --> 00:20:35.650
So the copy has the name of Ristorante Roma,

376
00:20:35.650 --> 00:20:38.420
and the old one has Classico Italiano,

377
00:20:38.420 --> 00:20:39.760
which means that, indeed,

378
00:20:39.760 --> 00:20:43.150
we did make a copy of the original restaurant.

379
00:20:43.150 --> 00:20:45.230
Because otherwise, as we learned

380
00:20:45.230 --> 00:20:47.110
by the end of the previous section,

381
00:20:47.110 --> 00:20:50.890
changing one object would then also change the other one.

382
00:20:50.890 --> 00:20:53.290
Right? Cool.

383
00:20:53.290 --> 00:20:55.840
So another long lecture here,

384
00:20:55.840 --> 00:20:59.030
but we're making really great progress.

385
00:20:59.030 --> 00:21:00.850
And of course, we will use all of this

386
00:21:00.850 --> 00:21:03.760
in real projects later down the road.

387
00:21:03.760 --> 00:21:06.510
But again, I chose to teach you these concepts

388
00:21:06.510 --> 00:21:09.900
in a separate way and not inside a big project,

389
00:21:09.900 --> 00:21:11.540
because this allows me to show you

390
00:21:11.540 --> 00:21:13.750
a lot more different examples

391
00:21:13.750 --> 00:21:16.780
and it also makes the material more reference-able

392
00:21:16.780 --> 00:21:18.350
for you in the future.

393
00:21:18.350 --> 00:21:19.900
And so that's gonna be helpful

394
00:21:19.900 --> 00:21:22.490
when you're trying to find what you're looking for

395
00:21:22.490 --> 00:21:24.023
after taking this course.

