WEBVTT

1
00:00:01.350 --> 00:00:03.340
<v Narrator>In this video, we're gonna talk about</v>

2
00:00:03.340 --> 00:00:06.230
the third data transformations method,

3
00:00:06.230 --> 00:00:08.363
which is the reduce method.

4
00:00:09.810 --> 00:00:11.480
And as you will remember,

5
00:00:11.480 --> 00:00:15.680
we use the reduce method to essentially boil down

6
00:00:15.680 --> 00:00:20.300
all the elements in an array to one single value.

7
00:00:20.300 --> 00:00:22.400
And we talked about the example of

8
00:00:22.400 --> 00:00:25.976
adding up all the numbers in one array, right?

9
00:00:25.976 --> 00:00:29.443
And so let's try that now with all movements array.

10
00:00:31.130 --> 00:00:35.493
And remember that array looks like this. Okay.

11
00:00:36.354 --> 00:00:39.190
And then by adding up all these numbers,

12
00:00:39.190 --> 00:00:41.682
so both the deposits and the withdrawals,

13
00:00:41.682 --> 00:00:46.682
we end up with the global balance of the account, basically.

14
00:00:46.850 --> 00:00:51.320
So let's start using the reduce method here.

15
00:00:51.320 --> 00:00:52.630
And so, as I just said,

16
00:00:52.630 --> 00:00:57.360
we're gonna call it on the movements array.

17
00:00:57.360 --> 00:01:00.590
And the results of the reduce method will be,

18
00:01:00.590 --> 00:01:04.223
as I just said, the global balance of the account.

19
00:01:06.260 --> 00:01:08.850
So let's call the result, balance.

20
00:01:08.850 --> 00:01:10.540
And remember that in this case,

21
00:01:10.540 --> 00:01:13.309
this balance will be simply one value

22
00:01:13.309 --> 00:01:15.383
and not an entire array.

23
00:01:16.928 --> 00:01:21.928
Okay. So the reduce function also gets a callback function,

24
00:01:22.610 --> 00:01:26.050
but this one is a little bit different from the other ones,

25
00:01:26.050 --> 00:01:28.825
like the one in map or for each.

26
00:01:28.825 --> 00:01:30.593
So in these other callbacks,

27
00:01:30.593 --> 00:01:32.860
the first parameter is always

28
00:01:32.860 --> 00:01:36.240
the current element of the array.

29
00:01:36.240 --> 00:01:37.500
Let's call it current.

30
00:01:37.500 --> 00:01:39.490
The second one is the current index

31
00:01:39.490 --> 00:01:42.630
and the third one is the entire array.

32
00:01:42.630 --> 00:01:45.915
But here in the callback function of the reduce method,

33
00:01:45.915 --> 00:01:48.410
the first parameter is actually

34
00:01:48.410 --> 00:01:50.950
something called the accumulator.

35
00:01:50.950 --> 00:01:55.030
So let's call it acc like this

36
00:01:55.030 --> 00:01:57.890
as an abbreviation of accumulator.

37
00:01:57.890 --> 00:02:02.030
And this accumulator is essentially like a snowball

38
00:02:02.030 --> 00:02:04.193
that keeps accumulating the value

39
00:02:04.193 --> 00:02:06.570
that we ultimately want to return.

40
00:02:06.570 --> 00:02:09.650
So in the case of adding all the elements

41
00:02:09.650 --> 00:02:12.445
or all the numbers of an array together,

42
00:02:12.445 --> 00:02:14.780
that will be the sum.

43
00:02:14.780 --> 00:02:16.580
So let me write that here.

44
00:02:16.580 --> 00:02:17.413
Oops.

45
00:02:18.410 --> 00:02:21.370
So let me write accumulator

46
00:02:22.260 --> 00:02:24.303
it's like a snowball.

47
00:02:25.779 --> 00:02:26.923
All right.

48
00:02:29.200 --> 00:02:33.520
But anyway, let's not write the actual function block here.

49
00:02:33.520 --> 00:02:36.710
So as always, this callback function here

50
00:02:36.710 --> 00:02:38.940
will be called in each iteration

51
00:02:38.940 --> 00:02:41.460
of a looping over the array.

52
00:02:41.460 --> 00:02:44.100
So reduce also loops over the array

53
00:02:44.100 --> 00:02:47.480
and calls this callback in each iteration,

54
00:02:47.480 --> 00:02:50.050
but now what will we actually do

55
00:02:50.050 --> 00:02:51.998
in each of these iterations?

56
00:02:51.998 --> 00:02:55.333
Well, since the accumulator is the value

57
00:02:55.333 --> 00:02:58.890
that we will keep adding to what we're gonna do here

58
00:02:58.890 --> 00:03:02.063
is to add the current value to the accumulator.

59
00:03:03.360 --> 00:03:08.360
So the accumulator plus the current value. Okay.

60
00:03:09.510 --> 00:03:12.060
And this works because in each call of

61
00:03:12.060 --> 00:03:13.310
the callback function,

62
00:03:13.310 --> 00:03:15.840
the accumulator will be the current sum

63
00:03:15.840 --> 00:03:18.190
of all the previous values.

64
00:03:18.190 --> 00:03:21.430
And so we will really keep adding to this accumulator

65
00:03:21.430 --> 00:03:23.673
in each iteration of the loop.

66
00:03:25.010 --> 00:03:28.660
Finally, we also need to return this value here

67
00:03:28.660 --> 00:03:30.000
from the callback.

68
00:03:30.000 --> 00:03:32.240
And so this is how the new accumulator

69
00:03:32.240 --> 00:03:35.992
can then be used in the next iteration of the loop.

70
00:03:35.992 --> 00:03:38.770
So basically in each loop iteration,

71
00:03:38.770 --> 00:03:41.325
we return the updated accumulator

72
00:03:41.325 --> 00:03:44.465
so the current one, plus the new current value.

73
00:03:44.465 --> 00:03:48.010
And so like this, we can then keep adding to it

74
00:03:48.010 --> 00:03:49.863
in the next iteration.

75
00:03:49.863 --> 00:03:50.763
Okay?

76
00:03:51.610 --> 00:03:55.810
So this callback function is the first argument

77
00:03:55.810 --> 00:03:57.600
of the reduce method,

78
00:03:57.600 --> 00:04:01.010
but the reduce method actually has a another,

79
00:04:01.010 --> 00:04:03.020
so a second parameter,

80
00:04:03.020 --> 00:04:06.640
and that is the initial value of the accumulator.

81
00:04:06.640 --> 00:04:08.794
So the value that we specify here,

82
00:04:08.794 --> 00:04:12.763
which in this case is gonna be zero is the initial value

83
00:04:12.763 --> 00:04:16.300
of the accumulator in the first loop iteration.

84
00:04:16.300 --> 00:04:20.047
And so in this example, we want to start counting

85
00:04:20.047 --> 00:04:23.420
or we want to start adding at zero.

86
00:04:23.420 --> 00:04:26.893
And so therefore we simply specify zero here.

87
00:04:30.290 --> 00:04:32.626
Okay, and with this we should be able

88
00:04:32.626 --> 00:04:35.441
to already take a look at our balance.

89
00:04:35.441 --> 00:04:39.450
And yeah, so we have one single number.

90
00:04:39.450 --> 00:04:44.450
So indeed everything was boiled down to this one number,

91
00:04:45.250 --> 00:04:48.580
which we can suppose is all of these values here

92
00:04:48.580 --> 00:04:51.339
added together, all right.

93
00:04:51.339 --> 00:04:54.179
And to make this even more clear to see,

94
00:04:54.179 --> 00:04:58.920
that's actually always log the accumulator to the console.

95
00:04:58.920 --> 00:05:02.877
So let's say iteration number I

96
00:05:06.430 --> 00:05:08.233
and enter the accumulator in there.

97
00:05:12.180 --> 00:05:15.380
Okay, so we see that in iteration zero,

98
00:05:15.380 --> 00:05:17.970
the accumulator is zero.

99
00:05:17.970 --> 00:05:20.710
And so this is the value that we specified here

100
00:05:20.710 --> 00:05:23.800
as the starter so as the initial value.

101
00:05:23.800 --> 00:05:25.170
Then in the second iteration,

102
00:05:25.170 --> 00:05:28.090
the accumulator is already at 200

103
00:05:28.090 --> 00:05:30.589
and that's because that is the initial value

104
00:05:30.589 --> 00:05:33.870
plus the current value in the previous iteration.

105
00:05:33.870 --> 00:05:35.283
So that was 200 there.

106
00:05:37.091 --> 00:05:41.220
And so this zero plus the 200 creates the new accumulator,

107
00:05:41.220 --> 00:05:44.460
which is done in the next iteration, 200.

108
00:05:44.460 --> 00:05:48.000
Then in this iteration, we add the current value again,

109
00:05:48.000 --> 00:05:49.840
which is 450.

110
00:05:49.840 --> 00:05:52.190
So that result is 650.

111
00:05:52.190 --> 00:05:53.888
And therefore in the next iteration,

112
00:05:53.888 --> 00:05:56.263
that's the value of the accumulator.

113
00:05:57.250 --> 00:05:59.532
Okay. And so here you can really see

114
00:05:59.532 --> 00:06:02.970
like the snowball effect of all of these values,

115
00:06:02.970 --> 00:06:05.530
adding up to one final value.

116
00:06:05.530 --> 00:06:09.279
And in the end, that value is essentially the accumulator.

117
00:06:09.279 --> 00:06:11.770
Now here we see the value of going down

118
00:06:11.770 --> 00:06:13.200
because in this iteration,

119
00:06:13.200 --> 00:06:15.340
we are adding minus 400

120
00:06:15.340 --> 00:06:19.533
and so 250 is 650 minus 400.

121
00:06:21.330 --> 00:06:25.283
Okay, so in the last iteration the value is 2,540,

122
00:06:27.520 --> 00:06:31.080
and then adding 1,300 will eventually result

123
00:06:31.080 --> 00:06:32.943
in this value here.

124
00:06:33.970 --> 00:06:38.420
Great. So this is really how the reduce method works.

125
00:06:38.420 --> 00:06:40.260
And I think this a log here

126
00:06:40.260 --> 00:06:42.333
is a great visualization of that.

127
00:06:43.230 --> 00:06:45.833
Let's give it all the space we need.

128
00:06:45.833 --> 00:06:48.986
And let me just change this one here to 100,

129
00:06:48.986 --> 00:06:52.870
so that you see the effect of changing this.

130
00:06:52.870 --> 00:06:56.220
And so now we can expect this accumulator

131
00:06:56.220 --> 00:06:59.320
in the beginning being 100.

132
00:06:59.320 --> 00:07:02.660
And so we already start with a small snowball here,

133
00:07:02.660 --> 00:07:04.981
which then we keep adding to,

134
00:07:04.981 --> 00:07:09.347
and therefore our final balance is now 100 euros

135
00:07:09.347 --> 00:07:12.793
or whatever it is larger.

136
00:07:13.950 --> 00:07:18.300
Okay. And yeah,

137
00:07:18.300 --> 00:07:21.270
let's one more time do the same thing manually,

138
00:07:21.270 --> 00:07:22.903
basically with a four loop.

139
00:07:26.140 --> 00:07:29.480
So of movements.

140
00:07:29.480 --> 00:07:33.380
And so we need one more time, an external variable here,

141
00:07:33.380 --> 00:07:35.907
which is gonna be the sum.

142
00:07:35.907 --> 00:07:39.290
Well, let's call it balance two.

143
00:07:39.290 --> 00:07:41.770
So balance two starts at zero.

144
00:07:41.770 --> 00:07:42.920
And so essentially this is,

145
00:07:42.920 --> 00:07:46.630
or initial accumulator value just like this zero

146
00:07:47.800 --> 00:07:52.800
and then sum plus equal the current movement.

147
00:07:54.750 --> 00:07:58.623
And if we lock balance two, we will get, okay.

148
00:08:00.330 --> 00:08:03.903
Now of course this has to be balance two,

149
00:08:03.903 --> 00:08:07.320
but now we get indeed the same result.

150
00:08:07.320 --> 00:08:10.800
And so here you can see this common pattern

151
00:08:10.800 --> 00:08:13.090
that we always need an external variable

152
00:08:13.090 --> 00:08:16.160
whenever we want to use a for loop.

153
00:08:16.160 --> 00:08:18.840
And that's fine if you only need one loop,

154
00:08:18.840 --> 00:08:21.870
but it starts to become really cumbersome

155
00:08:21.870 --> 00:08:24.710
and unpractical when we use many loops

156
00:08:24.710 --> 00:08:26.588
for doing many operations.

157
00:08:26.588 --> 00:08:29.350
So these methods that we've been studying,

158
00:08:29.350 --> 00:08:32.340
they completely avoid this extra variable

159
00:08:32.340 --> 00:08:34.570
and they simply return the variable

160
00:08:34.570 --> 00:08:37.238
or the value actually right away.

161
00:08:37.238 --> 00:08:38.153
All right.

162
00:08:39.278 --> 00:08:44.278
And of course we can write here in an even simpler way.

163
00:08:45.035 --> 00:08:47.127
So using an arrow function

164
00:08:47.127 --> 00:08:49.079
and I will still keep this here

165
00:08:49.079 --> 00:08:52.283
so that we can see the return that's happening.

166
00:08:53.670 --> 00:08:56.291
So first we can get rid of this.

167
00:08:56.291 --> 00:08:58.720
Then we get rid of this.

168
00:08:58.720 --> 00:09:00.633
We also don't need any of this,

169
00:09:01.490 --> 00:09:06.100
but here we always use or need the accumulator

170
00:09:06.100 --> 00:09:07.303
and the current value.

171
00:09:08.290 --> 00:09:09.870
So here we need parenthesis

172
00:09:10.800 --> 00:09:12.556
then the arrow.

173
00:09:12.556 --> 00:09:17.556
And then as always, we can get rid of all of this.

174
00:09:18.830 --> 00:09:23.710
And so now still, or balanced is the same. Awesome.

175
00:09:23.710 --> 00:09:26.700
So understanding how the reduce method works

176
00:09:26.700 --> 00:09:28.940
is something really important,

177
00:09:28.940 --> 00:09:32.220
but it's also way more confusing than the other ones,

178
00:09:32.220 --> 00:09:34.350
but I'm sure you're well underway

179
00:09:34.350 --> 00:09:36.366
of really understanding it.

180
00:09:36.366 --> 00:09:38.740
And now that we know how it works,

181
00:09:38.740 --> 00:09:42.600
we can actually now also calculate the balance

182
00:09:42.600 --> 00:09:46.460
of these movements here and then print that balance

183
00:09:46.460 --> 00:09:49.663
right here to our application and user interface.

184
00:09:50.560 --> 00:09:53.243
And so let's go ahead and do that here.

185
00:09:54.490 --> 00:09:57.155
So finally back to our application here.

186
00:09:57.155 --> 00:10:00.103
And so let's do that down here.

187
00:10:01.810 --> 00:10:06.363
So calc and print, balance.

188
00:10:09.880 --> 00:10:12.380
And so this function here will once again,

189
00:10:12.380 --> 00:10:15.273
receive the movements as an input.

190
00:10:16.110 --> 00:10:18.273
So any array of movements will work.

191
00:10:19.363 --> 00:10:24.363
And so now let's calculate the balance based on this array.

192
00:10:26.380 --> 00:10:29.943
And essentially this is exactly what we wrote to before.

193
00:10:31.220 --> 00:10:35.220
So that's movement dot reduce,

194
00:10:35.220 --> 00:10:38.360
but it doesn't hurt to write it here again.

195
00:10:38.360 --> 00:10:42.680
So remember the first parameter is now the accumulator

196
00:10:42.680 --> 00:10:45.810
and only the second one is the current value.

197
00:10:45.810 --> 00:10:48.163
So let's call it the movement now.

198
00:10:49.915 --> 00:10:54.372
And so here simply we return the accumulator

199
00:10:54.372 --> 00:10:58.793
plus the current movement and we start at zero.

200
00:10:59.750 --> 00:11:03.330
Great. And now all we need to do is to display it

201
00:11:03.330 --> 00:11:05.210
here in this element.

202
00:11:05.210 --> 00:11:10.210
So let's check this out and it is called the balance value.

203
00:11:10.500 --> 00:11:13.593
And just like before I already have it selected here,

204
00:11:14.840 --> 00:11:19.300
and this is a label, so balance value is here.

205
00:11:19.300 --> 00:11:21.047
So I called it label balance

206
00:11:21.047 --> 00:11:24.110
and so label is basically all the things

207
00:11:24.110 --> 00:11:27.983
where we simply want to put some text, all right?

208
00:11:33.785 --> 00:11:36.607
So let's say label balance dot text content.

209
00:11:37.620 --> 00:11:42.060
And this one we already know equals the balance

210
00:11:43.000 --> 00:11:47.470
and let's actually do a template string here,

211
00:11:47.470 --> 00:11:51.926
or a template literal and also display the Euro sign.

212
00:11:51.926 --> 00:11:53.710
Well, I don't know where it is,

213
00:11:53.710 --> 00:11:57.419
so let's just write EUR, which also means EURO.

214
00:11:57.419 --> 00:12:02.419
And so now let's see of course

215
00:12:02.720 --> 00:12:04.363
we didn't call the function yet.

216
00:12:05.210 --> 00:12:07.360
So let's do that here as well.

217
00:12:07.360 --> 00:12:10.670
And actually let's put this function here

218
00:12:10.670 --> 00:12:12.690
where it makes a little bit more sense

219
00:12:13.800 --> 00:12:17.693
because it kind of belongs to this display movements here.

220
00:12:18.955 --> 00:12:22.080
Okay. So let's actually also call this one here,

221
00:12:22.080 --> 00:12:25.633
calc and display balance.

222
00:12:26.610 --> 00:12:30.548
So to give it a similar name as that one.

223
00:12:30.548 --> 00:12:34.430
And so now I'm gonna call it, calc display balance.

224
00:12:34.430 --> 00:12:38.532
And once again, I'm calling it with account one.

225
00:12:38.532 --> 00:12:42.063
So account one dot movements,

226
00:12:43.090 --> 00:12:46.590
and then later on, as we keep developing this application

227
00:12:46.590 --> 00:12:49.800
of course these movements here that we're gonna use

228
00:12:49.800 --> 00:12:53.490
will be from the account that locked into the application.

229
00:12:53.490 --> 00:12:56.270
So if Jonas locked into the application,

230
00:12:56.270 --> 00:12:59.554
then Jonas's movements will be shown and Jonas balance.

231
00:12:59.554 --> 00:13:02.560
But if Steven locks in then of course

232
00:13:02.560 --> 00:13:06.910
Steven's movements and Steven's balance will be shown here.

233
00:13:06.910 --> 00:13:10.648
And right now we already see our balance up here.

234
00:13:10.648 --> 00:13:13.903
And so this actually happens to be exactly the same

235
00:13:13.903 --> 00:13:16.610
we calculated before.

236
00:13:16.610 --> 00:13:19.490
So also 3,840,

237
00:13:19.490 --> 00:13:23.453
because the movements are indeed also exactly the same.

238
00:13:23.453 --> 00:13:28.453
Great. So that's beautiful with this,

239
00:13:28.460 --> 00:13:31.776
we actually already completed some parts here

240
00:13:31.776 --> 00:13:34.370
of our flow chart.

241
00:13:34.370 --> 00:13:37.773
So let's also keep this one handy here

242
00:13:37.773 --> 00:13:40.163
so that we can keep looking at it.

243
00:13:40.163 --> 00:13:43.680
And so we already did calculating the balance

244
00:13:43.680 --> 00:13:45.380
and displaying the balance.

245
00:13:45.380 --> 00:13:47.726
So we did all this in just one function

246
00:13:47.726 --> 00:13:51.547
and we also already have this playing the movements.

247
00:13:51.547 --> 00:13:54.651
So indeed we are making some nice progress here.

248
00:13:54.651 --> 00:13:56.670
And the rest that you see here

249
00:13:56.670 --> 00:14:00.095
will be even easier as we go on.

250
00:14:00.095 --> 00:14:03.454
Now, just to finish this lecture here about reduce

251
00:14:03.454 --> 00:14:06.260
let me show you one final example

252
00:14:07.190 --> 00:14:09.422
because we can also do other stuff,

253
00:14:09.422 --> 00:14:12.090
than just adding up values

254
00:14:12.090 --> 00:14:15.220
that would become boring at some point, right?

255
00:14:15.220 --> 00:14:18.251
And so we can also do other stuff.

256
00:14:18.251 --> 00:14:22.780
So this time, what I want to do is to get the maximum value

257
00:14:24.750 --> 00:14:26.918
of the movements array here.

258
00:14:26.918 --> 00:14:29.880
Okay, so in this case,

259
00:14:29.880 --> 00:14:32.910
the result we're looking for is this 3,000.

260
00:14:32.910 --> 00:14:36.840
Okay. And so for that, we can also use reduce,

261
00:14:36.840 --> 00:14:40.688
because remember reduce is for boiling down the array

262
00:14:40.688 --> 00:14:43.410
into just one single value,

263
00:14:43.410 --> 00:14:46.100
but that value can be whatever we want.

264
00:14:46.100 --> 00:14:47.800
So it doesn't have to be a sum.

265
00:14:47.800 --> 00:14:49.654
It could be a multiplication

266
00:14:49.654 --> 00:14:52.160
or even something completely different,

267
00:14:52.160 --> 00:14:54.768
like a string or an object,

268
00:14:54.768 --> 00:14:57.930
but here we will keep working with numbers,

269
00:14:57.930 --> 00:15:00.113
but this time we want the maximum number.

270
00:15:01.170 --> 00:15:04.720
So let's kind of go manually through this array

271
00:15:04.720 --> 00:15:08.155
to determine what the reduce method should do.

272
00:15:08.155 --> 00:15:10.700
So let's start here at 200.

273
00:15:10.700 --> 00:15:13.580
Is this the maximum value at this point?

274
00:15:13.580 --> 00:15:16.870
Well, we don't know yet because we just started,

275
00:15:16.870 --> 00:15:21.520
so let's save 200 here mentally as our current maximum,

276
00:15:21.520 --> 00:15:25.930
then we move on to the next value and we see 450.

277
00:15:25.930 --> 00:15:28.800
So is this greater than our current maximum,

278
00:15:28.800 --> 00:15:30.860
which was 200?

279
00:15:30.860 --> 00:15:33.200
Well, yes it is, it is greater.

280
00:15:33.200 --> 00:15:37.640
And so 450 is now our current maximum

281
00:15:37.640 --> 00:15:41.433
then minus 400 is of course less than our current maximum.

282
00:15:41.433 --> 00:15:43.602
Then we move on even further.

283
00:15:43.602 --> 00:15:48.060
So 3,000 is a greater than our current maximum?

284
00:15:48.060 --> 00:15:49.260
Yes it is.

285
00:15:49.260 --> 00:15:52.200
And so that becomes our current maximum.

286
00:15:52.200 --> 00:15:54.520
So we store this 3,000

287
00:15:54.520 --> 00:15:56.867
and then we keep going through the array.

288
00:15:56.867 --> 00:16:01.867
And as you see, there is no other value greater than 3,000.

289
00:16:02.120 --> 00:16:06.943
And so in the end or maximum was this one, so 3,000.

290
00:16:08.950 --> 00:16:11.900
Okay. And now all we need to do is to

291
00:16:11.900 --> 00:16:14.760
essentially translate this into code,

292
00:16:14.760 --> 00:16:16.303
using the reduce method.

293
00:16:18.660 --> 00:16:23.363
So let's call it max movements to reduce.

294
00:16:24.670 --> 00:16:27.360
And as always, we need the accumulator

295
00:16:27.360 --> 00:16:29.120
and the current value.

296
00:16:29.120 --> 00:16:31.020
So I'm calling it movement here again.

297
00:16:32.320 --> 00:16:33.300
All right.

298
00:16:33.300 --> 00:16:36.010
And now this time, what should be the purpose

299
00:16:36.010 --> 00:16:38.190
of this accumulator value?

300
00:16:38.190 --> 00:16:40.639
So that's always the big question that we have to ask

301
00:16:40.639 --> 00:16:42.640
when we use reduce.

302
00:16:42.640 --> 00:16:46.257
So up here, when we wanted to add all the numbers together,

303
00:16:46.257 --> 00:16:48.600
the purpose of the accumulator

304
00:16:48.600 --> 00:16:51.600
was to keep track of the current sum.

305
00:16:51.600 --> 00:16:54.233
And so here, the accumulator will be the one

306
00:16:54.233 --> 00:16:57.393
that will keep track of the current maximum value.

307
00:16:58.270 --> 00:17:02.090
So let's just start by writing the logic here

308
00:17:02.090 --> 00:17:05.387
in a bigger way so we can understand what's happening.

309
00:17:05.387 --> 00:17:07.080
And then I will simplify it

310
00:17:07.080 --> 00:17:10.432
to make this a one-liner function one more time.

311
00:17:10.432 --> 00:17:15.288
So translating the logic that we just went over here

312
00:17:15.288 --> 00:17:19.588
is to say, if the accumulator is greater

313
00:17:19.588 --> 00:17:21.660
than the current value,

314
00:17:21.660 --> 00:17:26.660
which is the movement, then return the accumulator, right?

315
00:17:28.640 --> 00:17:30.350
Because in the reduce method,

316
00:17:30.350 --> 00:17:34.010
we always have to somehow return the accumulator

317
00:17:34.010 --> 00:17:35.860
to the next iteration.

318
00:17:35.860 --> 00:17:38.940
And in this case, we simply want to keep the accumulator

319
00:17:38.940 --> 00:17:42.332
at the value that it already is and not change it.

320
00:17:42.332 --> 00:17:47.332
Okay. We want to change it in the other scenario, basically.

321
00:17:48.310 --> 00:17:52.100
So when the current value is greater than the accumulator,

322
00:17:52.100 --> 00:17:54.050
so that would be this case here.

323
00:17:54.050 --> 00:17:57.230
So here, remember the current value is 450,

324
00:17:57.230 --> 00:17:59.594
but the accumulator is 200.

325
00:17:59.594 --> 00:18:03.529
And so now the movement is greater than accumulator.

326
00:18:03.529 --> 00:18:06.990
And so what we want to return here as the accumulator

327
00:18:06.990 --> 00:18:09.883
in the next iteration is the current movement.

328
00:18:12.944 --> 00:18:15.813
And so that's it, okay.

329
00:18:17.040 --> 00:18:19.390
And now we also need the initial value.

330
00:18:19.390 --> 00:18:23.480
And so the initial value make sense to be

331
00:18:23.480 --> 00:18:26.230
this first value here of the array.

332
00:18:26.230 --> 00:18:31.128
Okay. And so that's movements at position zero.

333
00:18:31.128 --> 00:18:33.400
Now we could have used zero here,

334
00:18:33.400 --> 00:18:35.540
but that would not be correct

335
00:18:35.540 --> 00:18:37.770
because imagine that the first value

336
00:18:37.770 --> 00:18:39.783
would be like a negative,

337
00:18:39.783 --> 00:18:42.810
then this might not work as expected.

338
00:18:42.810 --> 00:18:45.020
Maybe it might work with the maximum,

339
00:18:45.020 --> 00:18:47.334
but not with a minimum, for example.

340
00:18:47.334 --> 00:18:50.010
So don't just put zero here

341
00:18:50.010 --> 00:18:53.410
when you're trying to find a maximum or a minimum value,

342
00:18:53.410 --> 00:18:56.800
always just go with the first value of the array.

343
00:18:56.800 --> 00:18:59.480
Okay. And that's it.

344
00:18:59.480 --> 00:19:00.960
Let's see if it works

345
00:19:00.960 --> 00:19:03.393
and then we can maybe go over this again.

346
00:19:06.040 --> 00:19:09.670
So indeed we get 3,000.

347
00:19:09.670 --> 00:19:12.420
So we started at 200.

348
00:19:12.420 --> 00:19:13.950
So in this iteration,

349
00:19:13.950 --> 00:19:17.040
is the accumulator greater than the movement?

350
00:19:17.040 --> 00:19:18.690
Well, it is not.

351
00:19:18.690 --> 00:19:23.300
And so return the current movement. Okay.

352
00:19:23.300 --> 00:19:25.245
But the first iteration is not that important.

353
00:19:25.245 --> 00:19:28.570
It gets interesting here in the second one.

354
00:19:28.570 --> 00:19:31.090
So now our accumulator is at 200

355
00:19:31.090 --> 00:19:34.360
and the current movement is at 450.

356
00:19:34.360 --> 00:19:36.970
So this one here is false again.

357
00:19:36.970 --> 00:19:39.190
And so now we return to movement

358
00:19:39.190 --> 00:19:42.220
as the new accumulator in the next iteration.

359
00:19:42.220 --> 00:19:44.710
All right. And so in the next iteration,

360
00:19:44.710 --> 00:19:47.289
that accumulator is 450 now,

361
00:19:47.289 --> 00:19:52.289
then here, the current movement is minus 400.

362
00:19:52.540 --> 00:19:57.540
And so here is 450 greater than minus 400.

363
00:19:57.830 --> 00:19:59.530
Yes, of course it is.

364
00:19:59.530 --> 00:20:01.840
And so let's simply return the accumulator

365
00:20:01.840 --> 00:20:04.970
so that it stays the same in the next iteration.

366
00:20:04.970 --> 00:20:06.910
And so that's the logic all the way

367
00:20:06.910 --> 00:20:08.800
until the end of the array.

368
00:20:08.800 --> 00:20:12.820
And, by this, we then end up with this maximum value.

369
00:20:12.820 --> 00:20:16.320
All right. So I hope that made sense.

370
00:20:16.320 --> 00:20:18.610
And in fact, there is a ton of things

371
00:20:18.610 --> 00:20:21.550
that we can do with this reduce method.

372
00:20:21.550 --> 00:20:24.863
It is by far the most powerful array method there is.

373
00:20:26.380 --> 00:20:27.490
And because of that,

374
00:20:27.490 --> 00:20:30.180
it can also be the hardest one to use.

375
00:20:30.180 --> 00:20:33.070
So we always need to think exactly what we want

376
00:20:33.070 --> 00:20:36.170
the accumulator and the core value to be

377
00:20:36.170 --> 00:20:37.765
and how they should interact.

378
00:20:37.765 --> 00:20:40.807
But I hope that with this exercise here

379
00:20:40.807 --> 00:20:44.210
I could demonstrate the thought process a little bit

380
00:20:44.210 --> 00:20:47.290
and throughout the section and the rest of the course,

381
00:20:47.290 --> 00:20:50.890
there will be some more exercises of the reduce method

382
00:20:50.890 --> 00:20:53.250
so that you can also learn better and better

383
00:20:53.250 --> 00:20:55.263
how to use it yourself one day.

