1
00:00:01,470 --> 00:00:03,190
<v Jonas>Let's start this section</v>

2
00:00:03,190 --> 00:00:06,520
by learning how numbers work in JavaScript,

3
00:00:06,520 --> 00:00:09,340
how to convert values to numbers

4
00:00:09,340 --> 00:00:13,713
and also how to check if certain values are numbers or not.

5
00:00:15,570 --> 00:00:17,424
And before starting this section,

6
00:00:17,424 --> 00:00:20,400
go ahead and open up your starter files

7
00:00:20,400 --> 00:00:23,680
for this section so that we can take a look here

8
00:00:23,680 --> 00:00:26,220
at the script.js.

9
00:00:26,220 --> 00:00:28,759
So as I said, in the last section,

10
00:00:28,759 --> 00:00:31,490
in this one, we will continue working

11
00:00:31,490 --> 00:00:34,532
on our Bankist application, okay?

12
00:00:34,532 --> 00:00:37,810
Now, what's different here

13
00:00:37,810 --> 00:00:40,930
is that now we have actually different data.

14
00:00:40,930 --> 00:00:44,793
So we have only two accounts now here

15
00:00:44,793 --> 00:00:48,210
and each account now has a new array,

16
00:00:48,210 --> 00:00:50,853
which contains the dates of the movements.

17
00:00:51,830 --> 00:00:53,910
We also have the currency property

18
00:00:53,910 --> 00:00:56,720
and a locale property.

19
00:00:56,720 --> 00:00:59,670
Now, right, and so we will use this data

20
00:00:59,670 --> 00:01:03,650
in later lectures of this section, okay?

21
00:01:03,650 --> 00:01:06,550
Then down here, we have the complete application

22
00:01:06,550 --> 00:01:08,850
that we built in the last section.

23
00:01:08,850 --> 00:01:10,820
And if you want, you can go ahead

24
00:01:10,820 --> 00:01:14,510
and replace this entire code that I have here

25
00:01:14,510 --> 00:01:18,300
with your own code from the last section, okay?

26
00:01:18,300 --> 00:01:21,560
What matters here is that we make the application work

27
00:01:21,560 --> 00:01:25,683
just as it was working by the end of the last section.

28
00:01:26,650 --> 00:01:27,780
All right?

29
00:01:27,780 --> 00:01:30,970
So again, we have the same application,

30
00:01:30,970 --> 00:01:33,700
only the starter data is a little bit different

31
00:01:33,700 --> 00:01:36,310
but everything else is the same.

32
00:01:36,310 --> 00:01:41,090
And so now let's start learning a little bit about numbers.

33
00:01:41,090 --> 00:01:43,680
And the first thing that you should know about numbers

34
00:01:43,680 --> 00:01:45,190
is that in JavaScript,

35
00:01:45,190 --> 00:01:47,940
all numbers are presented internally

36
00:01:47,940 --> 00:01:50,140
as floating point numbers.

37
00:01:50,140 --> 00:01:52,720
So basically, always as decimals,

38
00:01:52,720 --> 00:01:55,160
no matter if we actually write them

39
00:01:55,160 --> 00:01:59,020
as integers or as decimals.

40
00:01:59,020 --> 00:02:01,043
So we can show that by doing this.

41
00:02:03,770 --> 00:02:05,543
So we need a new terminal here.

42
00:02:10,640 --> 00:02:13,053
And so here is our application back again.

43
00:02:13,980 --> 00:02:16,763
Let's close this and open up the console.

44
00:02:17,940 --> 00:02:19,140
Give it some more space

45
00:02:20,300 --> 00:02:25,300
and so you see that 23 is, in fact, the same as 23.0.

46
00:02:26,010 --> 00:02:27,050
Okay?

47
00:02:27,050 --> 00:02:29,800
And that's the reason why we only have one data type

48
00:02:29,800 --> 00:02:31,560
for all numbers.

49
00:02:31,560 --> 00:02:34,360
Also, numbers are represented internally

50
00:02:34,360 --> 00:02:37,440
in a 64 base 2 format.

51
00:02:37,440 --> 00:02:40,230
So that means that numbers are always stored

52
00:02:40,230 --> 00:02:42,020
in a binary format.

53
00:02:42,020 --> 00:02:46,720
So basically, they're only composed of zeros and ones.

54
00:02:46,720 --> 00:02:48,630
Now, in this binary form,

55
00:02:48,630 --> 00:02:51,720
it is very hard to represent some fractions

56
00:02:51,720 --> 00:02:54,000
that are very easy to represent

57
00:02:54,000 --> 00:02:57,170
in the base 10 system that we are used to.

58
00:02:57,170 --> 00:03:02,120
So base 10 is basically the numbers from zero to nine,

59
00:03:02,120 --> 00:03:05,850
while binary is base 2

60
00:03:05,850 --> 00:03:10,460
and so that's the numbers zero and one.

61
00:03:10,460 --> 00:03:11,610
Okay?

62
00:03:11,610 --> 00:03:14,190
So as I was saying, there are certain numbers

63
00:03:14,190 --> 00:03:17,540
that are very difficult to represent in base 2.

64
00:03:17,540 --> 00:03:21,822
And one example of that is the fraction 0.1.

65
00:03:21,822 --> 00:03:26,446
And that then results in very weird results like this.

66
00:03:26,446 --> 00:03:29,550
And this is kind of a classic

67
00:03:29,550 --> 00:03:32,210
or a running joke in JavaScript

68
00:03:32,210 --> 00:03:35,177
because this result should, of course, be 0.3

69
00:03:36,150 --> 00:03:38,740
and not with all of these zeros here.

70
00:03:38,740 --> 00:03:41,486
But JavaScript simply has no better way

71
00:03:41,486 --> 00:03:43,570
of representing this number.

72
00:03:43,570 --> 00:03:45,970
So in base 10,

73
00:03:45,970 --> 00:03:50,970
1/10 is simply 0.1.

74
00:03:52,510 --> 00:03:54,820
And so that's very easy to represent.

75
00:03:54,820 --> 00:03:58,013
But, for example, if we were trying to do 3/10,

76
00:03:59,260 --> 00:04:03,700
then that is also impossible to represent for us, right?

77
00:04:03,700 --> 00:04:05,700
It would be this number here

78
00:04:05,700 --> 00:04:08,890
and three until infinity, okay?

79
00:04:08,890 --> 00:04:13,600
And so in binary, the same thing happens with 0.1.

80
00:04:13,600 --> 00:04:15,990
So we get basically an infinite fraction

81
00:04:15,990 --> 00:04:19,793
and that then results in a weird result like this one.

82
00:04:20,670 --> 00:04:23,540
Now, in some cases, JavaScript does some rounding

83
00:04:23,540 --> 00:04:25,760
behind the scenes to try its best

84
00:04:25,760 --> 00:04:27,740
to hide these problems

85
00:04:27,740 --> 00:04:30,310
but some operations, such as this one,

86
00:04:30,310 --> 00:04:32,620
simply cannot mask the fact

87
00:04:32,620 --> 00:04:33,760
that behind the scenes,

88
00:04:33,760 --> 00:04:36,750
they cannot represent certain fractions.

89
00:04:36,750 --> 00:04:40,130
And by the way, many other languages use the same system.

90
00:04:40,130 --> 00:04:42,580
For example, PHP or Ruby

91
00:04:42,580 --> 00:04:45,610
and so don't let anyone make fun of JavaScript

92
00:04:45,610 --> 00:04:47,840
because of this, okay?

93
00:04:47,840 --> 00:04:50,540
So we just have to accept that it works this way

94
00:04:50,540 --> 00:04:53,800
because we really cannot do anything against this.

95
00:04:53,800 --> 00:04:54,980
So just be aware

96
00:04:54,980 --> 00:04:58,740
that you cannot do like really precise scientific

97
00:04:58,740 --> 00:05:01,480
or financial calculations in JavaScript

98
00:05:01,480 --> 00:05:05,692
because eventually, you will run into a problem like this.

99
00:05:05,692 --> 00:05:10,692
So .2, which will result in false,

100
00:05:11,290 --> 00:05:14,140
which, of course, is incorrect as we know.

101
00:05:14,140 --> 00:05:17,550
This should be true but well, this is simply an error

102
00:05:17,550 --> 00:05:22,117
in JavaScript that we have to accept, okay?

103
00:05:22,117 --> 00:05:24,320
All right, now that we know

104
00:05:24,320 --> 00:05:26,690
how JavaScript represents numbers,

105
00:05:26,690 --> 00:05:29,690
let's go back to actually working with them.

106
00:05:29,690 --> 00:05:34,167
So we know how to convert a string to a number, right?

107
00:05:34,167 --> 00:05:37,610
So that's like this.

108
00:05:37,610 --> 00:05:40,050
But there's also an easier way.

109
00:05:40,050 --> 00:05:42,420
So kind of a trick that we can use,

110
00:05:42,420 --> 00:05:46,950
which is to, or actually this should be a string,

111
00:05:46,950 --> 00:05:49,173
otherwise that doesn't make much sense.

112
00:05:50,090 --> 00:05:51,480
But as I was saying,

113
00:05:51,480 --> 00:05:52,860
there is an easier way,

114
00:05:52,860 --> 00:05:56,600
which is simply plus 23 the string.

115
00:05:56,600 --> 00:05:57,433
And this works

116
00:05:57,433 --> 00:06:01,020
because when JavaScript sees the plus operator,

117
00:06:01,020 --> 00:06:02,930
it will do type coercion.

118
00:06:02,930 --> 00:06:05,010
So it will automatically convert all

119
00:06:05,010 --> 00:06:06,910
the operands to numbers.

120
00:06:06,910 --> 00:06:11,550
And so therefore, we see 23 here in both these cases.

121
00:06:11,550 --> 00:06:14,393
So in this purple color, which are numbers.

122
00:06:16,470 --> 00:06:19,530
So this here makes our code look a lot cleaner

123
00:06:19,530 --> 00:06:20,720
in my opinion

124
00:06:20,720 --> 00:06:23,450
and so let's now actually go to our project

125
00:06:23,450 --> 00:06:26,130
and replace all the occurrences of Number,

126
00:06:26,130 --> 00:06:28,503
simply with the plus sign.

127
00:06:29,700 --> 00:06:31,043
So here.

128
00:06:32,780 --> 00:06:35,530
And if I save it now, the Prettier extension

129
00:06:35,530 --> 00:06:38,020
should get rid of the parentheses here.

130
00:06:38,020 --> 00:06:38,923
And it does.

131
00:06:41,960 --> 00:06:44,003
So here and here.

132
00:06:46,980 --> 00:06:48,463
And here as well.

133
00:06:51,940 --> 00:06:53,173
And that should be it.

134
00:06:54,720 --> 00:06:55,853
Yeah, that's it.

135
00:06:56,750 --> 00:06:57,810
Great.

136
00:06:57,810 --> 00:07:00,070
And so our project will work the same

137
00:07:00,070 --> 00:07:02,120
but the code is a little bit cleaner now.

138
00:07:02,990 --> 00:07:07,083
Okay, so here we converted strings to numbers.

139
00:07:08,700 --> 00:07:11,793
But we can also do something called parsing.

140
00:07:13,210 --> 00:07:15,883
So we can parse a number from a string.

141
00:07:17,980 --> 00:07:19,950
So on the Number object,

142
00:07:19,950 --> 00:07:22,140
which is kind of this function here,

143
00:07:22,140 --> 00:07:23,910
but it's also an object in the end.

144
00:07:23,910 --> 00:07:28,040
Remember because every function is also an object.

145
00:07:28,040 --> 00:07:29,540
And this number object here

146
00:07:29,540 --> 00:07:32,363
has some methods to do parsing.

147
00:07:33,200 --> 00:07:34,890
So let's use parseInt

148
00:07:37,050 --> 00:07:39,950
and so here we can now specify a string

149
00:07:40,800 --> 00:07:44,330
and that string can even include some symbols.

150
00:07:44,330 --> 00:07:46,500
And JavaScript will then automatically try

151
00:07:46,500 --> 00:07:48,180
to figure out the number

152
00:07:48,180 --> 00:07:49,860
that is in this string.

153
00:07:49,860 --> 00:07:50,693
All right?

154
00:07:50,693 --> 00:07:52,750
And so here we get 30.

155
00:07:52,750 --> 00:07:54,410
And this is actually a number.

156
00:07:54,410 --> 00:07:55,950
It's not a string.

157
00:07:55,950 --> 00:07:57,280
All right?

158
00:07:57,280 --> 00:07:58,905
Now, in order to make this work,

159
00:07:58,905 --> 00:08:03,140
the string needs to start with a number.

160
00:08:03,140 --> 00:08:05,890
So if we have something like this,

161
00:08:05,890 --> 00:08:06,917
then it's not gonna work

162
00:08:06,917 --> 00:08:09,250
and we get not a number.

163
00:08:09,250 --> 00:08:10,260
Okay?

164
00:08:10,260 --> 00:08:13,180
So this is a little bit like type coercion

165
00:08:13,180 --> 00:08:14,810
but even more advanced

166
00:08:14,810 --> 00:08:17,320
because as we just saw,

167
00:08:17,320 --> 00:08:20,740
it tries to get rid of unnecessary symbols

168
00:08:20,740 --> 00:08:22,520
that are not numbers.

169
00:08:22,520 --> 00:08:24,930
And this can be very useful, for example,

170
00:08:24,930 --> 00:08:29,230
in this situation where we get some kind of unit from CSS

171
00:08:29,230 --> 00:08:32,710
and then need to get rid of that unit.

172
00:08:32,710 --> 00:08:33,909
Now, the parseInt function

173
00:08:33,909 --> 00:08:37,090
actually accepts a second argument,

174
00:08:37,090 --> 00:08:39,570
which is the so-called regex.

175
00:08:39,570 --> 00:08:42,530
And the regex is the base of the numeral system

176
00:08:42,530 --> 00:08:44,150
that we are using.

177
00:08:44,150 --> 00:08:47,460
So here we are simply using base 10 numbers.

178
00:08:47,460 --> 00:08:50,140
So numbers from zero to nine.

179
00:08:50,140 --> 00:08:52,890
And most of the time, we are doing that

180
00:08:52,890 --> 00:08:55,773
and so we should always pass in the number 10 here.

181
00:08:57,660 --> 00:09:01,970
Okay, so that can avoid some bugs in some situations.

182
00:09:01,970 --> 00:09:04,500
And you see the result here is the same.

183
00:09:04,500 --> 00:09:07,450
But if we were working, for example, with binary,

184
00:09:07,450 --> 00:09:09,840
then we would write two

185
00:09:09,840 --> 00:09:12,963
and then the result would be completely different.

186
00:09:14,090 --> 00:09:16,610
In this case, we cannot even see it.

187
00:09:16,610 --> 00:09:19,000
But let's just keep using 10 here.

188
00:09:19,000 --> 00:09:22,260
So this is with integers.

189
00:09:22,260 --> 00:09:24,660
So that's what the int here stands for.

190
00:09:24,660 --> 00:09:29,294
So parse integers but there's also parseFloat.

191
00:09:29,294 --> 00:09:34,294
So Number.parseFloat

192
00:09:35,730 --> 00:09:38,193
and let's now try 2.5rem.

193
00:09:41,830 --> 00:09:44,940
And so now it reads the decimal number here

194
00:09:44,940 --> 00:09:46,420
from our string.

195
00:09:46,420 --> 00:09:48,760
So a floating point number.

196
00:09:48,760 --> 00:09:52,053
Let's see what happens if we used Int.

197
00:09:53,230 --> 00:09:57,340
And then we only get the integer part, right?

198
00:09:57,340 --> 00:10:00,970
So it will then stop here at this decimal point

199
00:10:00,970 --> 00:10:03,660
but that, of course, not what we want.

200
00:10:03,660 --> 00:10:04,493
And by the way,

201
00:10:04,493 --> 00:10:08,160
we could even have like some white space down here

202
00:10:08,160 --> 00:10:11,383
that would not affect anything at all.

203
00:10:12,694 --> 00:10:14,060
All right?

204
00:10:14,060 --> 00:10:17,060
Now, by the way, these two functions here

205
00:10:17,060 --> 00:10:20,483
are actually also so-called global functions.

206
00:10:22,090 --> 00:10:24,833
So we would not have to call them on Number.

207
00:10:26,570 --> 00:10:28,383
So this here also works.

208
00:10:29,380 --> 00:10:31,890
Okay, but this is the more traditional

209
00:10:31,890 --> 00:10:34,150
and old-school way of doing it.

210
00:10:34,150 --> 00:10:35,590
Now in modern JavaScript,

211
00:10:35,590 --> 00:10:38,860
it is more encouraged to call these functions

212
00:10:38,860 --> 00:10:42,320
actually on the Number object, okay?

213
00:10:42,320 --> 00:10:46,010
So we say that Number here provides something

214
00:10:46,010 --> 00:10:48,530
called a namespace, all right?

215
00:10:48,530 --> 00:10:51,560
So a namespace for all these different functions,

216
00:10:51,560 --> 00:10:54,213
like parseFloat, and parseInt.

217
00:10:55,470 --> 00:10:58,900
But anyway, let's now explore another function

218
00:10:58,900 --> 00:11:01,310
of the Number namespace

219
00:11:01,310 --> 00:11:04,070
and that is the isNaN.

220
00:11:04,070 --> 00:11:05,573
So is not a number.

221
00:11:08,010 --> 00:11:09,583
So Number.IsNotaNumber.

222
00:11:11,740 --> 00:11:13,270
And we can use this one

223
00:11:13,270 --> 00:11:16,880
to basically check if any value is a number.

224
00:11:16,880 --> 00:11:20,750
Well, not any value but more about that later.

225
00:11:20,750 --> 00:11:23,570
So for example, if we pass 20,

226
00:11:23,570 --> 00:11:26,830
then here we got false.

227
00:11:26,830 --> 00:11:28,610
And so is it not a number?

228
00:11:28,610 --> 00:11:30,890
False, all right?

229
00:11:30,890 --> 00:11:33,133
So let's try the same with a string.

230
00:11:34,540 --> 00:11:35,373
20.

231
00:11:36,300 --> 00:11:39,510
And so here we also get false, all right?

232
00:11:39,510 --> 00:11:42,330
Because this also isn't not a number.

233
00:11:42,330 --> 00:11:46,160
It's just a regular value, right?

234
00:11:46,160 --> 00:11:49,454
But now let's try it by converting something.

235
00:11:49,454 --> 00:11:51,920
So for example, this string,

236
00:11:51,920 --> 00:11:54,490
if we try to convert it to a number,

237
00:11:54,490 --> 00:11:56,403
then this will be not a number.

238
00:11:57,900 --> 00:11:58,733
Right?

239
00:11:58,733 --> 00:12:00,293
And so therefore, it is true.

240
00:12:01,460 --> 00:12:03,173
So let's just do that here.

241
00:12:04,580 --> 00:12:06,283
So yeah, this works as well.

242
00:12:07,200 --> 00:12:10,440
And so you see this is, of course, not a number.

243
00:12:10,440 --> 00:12:11,750
All right?

244
00:12:11,750 --> 00:12:13,653
But let's try something else.

245
00:12:15,210 --> 00:12:20,070
Let's, for example, divide 23 by zero

246
00:12:20,070 --> 00:12:22,910
and maybe you know that dividing by zero

247
00:12:22,910 --> 00:12:25,900
gives us infinite, okay?

248
00:12:25,900 --> 00:12:27,810
So dividing by zero is something

249
00:12:27,810 --> 00:12:30,180
that's not allowed in mathematics

250
00:12:30,180 --> 00:12:33,070
and so it will give us infinity.

251
00:12:33,070 --> 00:12:36,600
So infinity is also not not a NaN

252
00:12:37,450 --> 00:12:40,223
and so therefore, we get false here as well.

253
00:12:41,070 --> 00:12:43,383
So let me just demonstrate that here.

254
00:12:44,910 --> 00:12:49,200
So indeed, this gives us this special value of infinity

255
00:12:49,200 --> 00:12:52,220
that also exists in JavaScript.

256
00:12:52,220 --> 00:12:55,510
And so this is not a number

257
00:12:55,510 --> 00:12:57,380
is actually not a perfect way

258
00:12:57,380 --> 00:12:59,880
for checking if a value is a number

259
00:12:59,880 --> 00:13:03,050
because it doesn't consider this use case

260
00:13:03,050 --> 00:13:05,660
and sometimes, this might very well happen.

261
00:13:05,660 --> 00:13:09,013
And therefore, there is a better method called isFinite.

262
00:13:11,730 --> 00:13:15,800
So Number.isFinite and let's try it

263
00:13:15,800 --> 00:13:17,108
with the same numbers.

264
00:13:17,108 --> 00:13:19,343
So here we get true.

265
00:13:21,060 --> 00:13:24,610
And okay, and so basically this should be the opposite now

266
00:13:24,610 --> 00:13:26,090
of this one

267
00:13:26,090 --> 00:13:28,800
because this is not not a number.

268
00:13:28,800 --> 00:13:30,133
But it is finite.

269
00:13:31,300 --> 00:13:32,438
Okay?

270
00:13:32,438 --> 00:13:34,593
Now, if you try it with 20,

271
00:13:35,740 --> 00:13:39,200
the string, then here we get false

272
00:13:39,200 --> 00:13:41,340
because it's not a number.

273
00:13:41,340 --> 00:13:43,210
And so this is actually better to check

274
00:13:43,210 --> 00:13:45,543
if something is a number or not.

275
00:13:47,000 --> 00:13:49,600
And I know this sounds a bit confusing,

276
00:13:49,600 --> 00:13:51,511
and the confusion comes from the fact

277
00:13:51,511 --> 00:13:53,820
that we have this weird thing here

278
00:13:53,820 --> 00:13:56,383
that is also called not a number.

279
00:13:57,250 --> 00:13:58,400
All right?

280
00:13:58,400 --> 00:14:00,700
And so therefore, I'm just telling you

281
00:14:00,700 --> 00:14:04,350
that the isFinite method is indeed the best way

282
00:14:04,350 --> 00:14:07,803
of checking if a value is a number.

283
00:14:10,640 --> 00:14:13,463
So a real number, not a string.

284
00:14:15,320 --> 00:14:16,820
All right?

285
00:14:16,820 --> 00:14:18,893
So let's try again this one here.

286
00:14:20,440 --> 00:14:21,760
Trying to convert it

287
00:14:21,760 --> 00:14:24,670
and we know that this here is not a number.

288
00:14:24,670 --> 00:14:27,843
So literally, this will be NaN.

289
00:14:28,730 --> 00:14:29,650
Right?

290
00:14:29,650 --> 00:14:31,913
And so this should be false as well.

291
00:14:33,130 --> 00:14:34,600
And it is.

292
00:14:34,600 --> 00:14:36,683
And now finally, this last use case,

293
00:14:37,950 --> 00:14:39,623
which gives us infinity.

294
00:14:42,060 --> 00:14:44,780
And so it is false as well.

295
00:14:44,780 --> 00:14:46,970
So that's where the name of the method

296
00:14:46,970 --> 00:14:48,300
actually comes from.

297
00:14:48,300 --> 00:14:52,663
So isFinite and so infinity is, of course, not finite.

298
00:14:54,110 --> 00:14:55,070
All right?

299
00:14:55,070 --> 00:14:57,470
And so this method is the ultimate method

300
00:14:57,470 --> 00:15:01,500
that you should use to check if any value is a number,

301
00:15:01,500 --> 00:15:04,960
at least when you're working with floating point numbers.

302
00:15:04,960 --> 00:15:06,300
So if you are sure

303
00:15:06,300 --> 00:15:08,860
that you just need to check for an integer,

304
00:15:08,860 --> 00:15:11,113
then you can use isInteger as well.

305
00:15:12,598 --> 00:15:16,393
So let me just write here a comment as well.

306
00:15:17,540 --> 00:15:19,130
So this one you should only use

307
00:15:19,130 --> 00:15:24,130
to check if value is not a number.

308
00:15:24,250 --> 00:15:27,934
So literally, not a number this value.

309
00:15:27,934 --> 00:15:28,913
Okay?

310
00:15:31,070 --> 00:15:32,800
But usually, in practice,

311
00:15:32,800 --> 00:15:34,520
I never use this.

312
00:15:34,520 --> 00:15:36,660
Whenever I need to check for a number,

313
00:15:36,660 --> 00:15:38,440
this is the one to go

314
00:15:38,440 --> 00:15:40,820
or if I'm using integers,

315
00:15:40,820 --> 00:15:45,273
then I use isInteger as I was just saying before.

316
00:15:46,440 --> 00:15:47,893
So we can do this.

317
00:15:49,560 --> 00:15:53,470
Also this is also an integer remember

318
00:15:53,470 --> 00:15:56,930
and so both are true, okay?

319
00:15:56,930 --> 00:16:00,910
But then, of course, if we try this here,

320
00:16:00,910 --> 00:16:02,940
it will be false.

321
00:16:02,940 --> 00:16:05,550
Now, in our project that we're currently building,

322
00:16:05,550 --> 00:16:07,970
there's not really a need to check

323
00:16:07,970 --> 00:16:11,260
if any of the inputs is really a number or not

324
00:16:11,260 --> 00:16:13,260
and so in this particular case,

325
00:16:13,260 --> 00:16:15,730
we don't need to go back and change anything

326
00:16:15,730 --> 00:16:17,970
but it's still good to know about,

327
00:16:17,970 --> 00:16:20,150
especially this method here.

328
00:16:20,150 --> 00:16:21,600
So this is your go-to

329
00:16:21,600 --> 00:16:23,010
whenever you need to check

330
00:16:23,010 --> 00:16:25,818
if something is a number or not.

331
00:16:25,818 --> 00:16:28,270
And going back here,

332
00:16:28,270 --> 00:16:30,750
the parseFloat function should be your go-to

333
00:16:30,750 --> 00:16:34,284
whenever you need to read a value out of a string.

334
00:16:34,284 --> 00:16:37,078
For example, coming from CSS.

335
00:16:37,078 --> 00:16:39,010
So then you always get this

336
00:16:39,010 --> 00:16:40,330
and it's very nice to be able

337
00:16:40,330 --> 00:16:43,023
to read the number out of the string.

